Haskell Language
Tuplas (pares, triples, ...)
Buscar..
Observaciones
Haskell no admite tuplas con un componente de forma nativa.
Las unidades (escritas
()) pueden entenderse como tuplas con cero componentes.No hay funciones predefinidas para extraer componentes de tuplas con más de dos componentes. Si cree que necesita dichas funciones, considere usar un tipo de datos personalizado con etiquetas de registro en lugar del tipo de tupla. Luego puede usar las etiquetas de registro como funciones para extraer los componentes.
Construir valores de tupla
Usa paréntesis y comas para crear tuplas. Usa una coma para crear un par.
(1, 2)
Usa más comas para crear tuplas con más componentes.
(1, 2, 3)
(1, 2, 3, 4)
Tenga en cuenta que también es posible declarar las tuplas en su forma no saturada.
(,) 1 2 -- equivalent to (1,2)
(,,) 1 2 3 -- equivalent to (1,2,3)
Las tuplas pueden contener valores de diferentes tipos.
("answer", 42, '?')
Las tuplas pueden contener valores complejos como listas o más tuplas.
([1, 2, 3], "hello", ('A', 65))
(1, (2, (3, 4), 5), 6)
Escribe tipos de tuplas
Usa paréntesis y comas para escribir tipos de tuplas. Usa una coma para escribir un tipo de par.
(Int, Int)
Usa más comas para escribir tipos de tuplas con más componentes.
(Int, Int, Int)
(Int, Int, Int, Int)
Las tuplas pueden contener valores de diferentes tipos.
(String, Int, Char)
Las tuplas pueden contener valores complejos como listas o más tuplas.
([Int], String, (Char, Int))
(Int, (Int, (Int, Int), Int), Int)
Patrón de coincidencia en las tuplas
La coincidencia de patrones en las tuplas utiliza los constructores de tuplas. Para hacer coincidir un par, por ejemplo, usaríamos el constructor (,) :
myFunction1 (a, b) = ...
Usamos más comas para hacer coincidir las tuplas con más componentes:
myFunction2 (a, b, c) = ...
myFunction3 (a, b, c, d) = ...
Los patrones de tupla pueden contener patrones complejos, como los patrones de lista o más patrones de tupla.
myFunction4 ([a, b, c], d, e) = ...
myFunction5 (a, (b, (c, d), e), f) = ...
Extraer componentes de la tupla.
Utilice las funciones fst y snd (de Prelude o Data.Tuple ) para extraer el primer y segundo componente de los pares.
fst (1, 2) -- evaluates to 1
snd (1, 2) -- evaluates to 2
O utilice la coincidencia de patrones.
case (1, 2) of (result, _) => result -- evaluates to 1
case (1, 2) of (_, result) => result -- evaluates to 2
La coincidencia de patrones también funciona para tuplas con más de dos componentes.
case (1, 2, 3) of (result, _, _) => result -- evaluates to 1
case (1, 2, 3) of (_, result, _) => result -- evaluates to 2
case (1, 2, 3) of (_, _, result) => result -- evaluates to 3
Haskell no proporciona funciones estándar como fst o snd para tuplas con más de dos componentes. La biblioteca de tuple en Hackage proporciona dichas funciones en el módulo Data.Tuple.Select .
Aplique una función binaria a una tupla (uncurrying)
Utilice la función uncurry (de Prelude o Data.Tuple ) para convertir una función binaria en una función en tuplas.
uncurry (+) (1, 2) -- computes 3
uncurry map (negate, [1, 2, 3]) -- computes [-1, -2, -3]
uncurry uncurry ((+), (1, 2)) -- computes 3
map (uncurry (+)) [(1, 2), (3, 4), (5, 6)] -- computes [3, 7, 11]
uncurry (curry f) -- computes the same as f
Aplicar una función de tupla a dos argumentos (currying)
Utilice la función de curry (de Prelude o Data.Tuple ) para convertir una función que lleva tuplas a una función que toma dos argumentos.
curry fst 1 2 -- computes 1
curry snd 1 2 -- computes 2
curry (uncurry f) -- computes the same as f
import Data.Tuple (swap)
curry swap 1 2 -- computes (2, 1)
Intercambiar pares de componentes
Use swap (de Data.Tuple ) para intercambiar los componentes de un par.
import Data.Tuple (swap)
swap (1, 2) -- evaluates to (2, 1)
O utilice la coincidencia de patrones.
case (1, 2) of (x, y) => (y, x) -- evaluates to (2, 1)
Rigidez de emparejar una tupla.
El patrón (p1, p2) es estricto en el constructor de tuplas más externo, lo que puede llevar a un comportamiento inesperado de rigor . Por ejemplo, la siguiente expresión diverge (usando Data.Function.fix ):
fix $ \(x, y) -> (1, 2)
ya que la coincidencia en (x, y) es estricta en el constructor de tuplas. Sin embargo, la siguiente expresión, que utiliza un patrón irrefutable , se evalúa como (1, 2) como se esperaba:
fix $ \ ~(x, y) -> (1, 2)
