Haskell Language
Tuplas (pares, triples, ...)

Observaciones

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)