Haskell Language
Tuples (paires, triples, ...)

Remarques

Construire des valeurs de tuple

Utilisez des parenthèses et des virgules pour créer des tuples. Utilisez une virgule pour créer une paire.

(1, 2)

Utilisez plus de virgules pour créer des tuples avec plus de composants.

(1, 2, 3)

(1, 2, 3, 4)

Notez qu'il est également possible de déclarer les tuples sous leur forme non gravée.

(,) 1 2     -- equivalent to (1,2)
(,,) 1 2 3  -- equivalent to (1,2,3)

Les tuples peuvent contenir des valeurs de différents types.

("answer", 42, '?')

Les tuples peuvent contenir des valeurs complexes telles que des listes ou plusieurs tuples.

([1, 2, 3], "hello", ('A', 65))

(1, (2, (3, 4), 5), 6)

Écrire des types de tuple

Utilisez des parenthèses et des virgules pour écrire les types de tuple. Utilisez une virgule pour écrire un type de paire.

(Int, Int)

Utilisez plus de virgules pour écrire des types de tuple avec plus de composants.

(Int, Int, Int)

(Int, Int, Int, Int)

Les tuples peuvent contenir des valeurs de différents types.

(String, Int, Char)

Les tuples peuvent contenir des valeurs complexes telles que des listes ou plusieurs tuples.

([Int], String, (Char, Int))

(Int, (Int, (Int, Int), Int), Int)

Match de motif sur les tuples

La correspondance de motif sur les tuples utilise les constructeurs de tuple. Pour correspondre à une paire par exemple, nous utiliserions le constructeur (,) :

myFunction1 (a, b) = ...

Nous utilisons plus de virgules pour faire correspondre les tuples avec plus de composants:

myFunction2 (a, b, c) = ...

myFunction3 (a, b, c, d) = ...

Les modèles de tuples peuvent contenir des motifs complexes tels que des motifs de liste ou plusieurs motifs de tuples.

myFunction4 ([a, b, c], d, e) = ...

myFunction5 (a, (b, (c, d), e), f) = ...

Extraire les composants du tuple

Utilisez les fonctions fst et snd (de Prelude ou Data.Tuple ) pour extraire le premier et le second composant des paires.

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

Ou utilisez la correspondance de motif.

case (1, 2) of (result, _) => result -- evaluates to 1

case (1, 2) of (_, result) => result -- evaluates to 2

La correspondance de motif fonctionne également pour les tuples comportant plus de deux composants.

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 ne fournit pas de fonctions standard telles que fst ou snd pour les tuples avec plus de deux composants. La bibliothèque de tuple sur Hackage fournit de telles fonctions dans le module Data.Tuple.Select .

Appliquer une fonction binaire à un tuple

Utilisez la fonction uncurry (à partir de Prelude ou Data.Tuple ) pour convertir une fonction binaire en fonction sur des tuples.

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

Appliquer une fonction tuple à deux arguments (currying)

Utilisez la fonction curry (de Prelude ou Data.Tuple ) pour convertir une fonction qui prend des tuples en une fonction qui prend deux arguments.

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)

Composants de la paire de swap

Utilisez swap (à partir de Data.Tuple ) pour échanger les composants d'une paire.

import Data.Tuple (swap)
swap (1, 2) -- evaluates to (2, 1)

Ou utilisez la correspondance de motif.

case (1, 2) of (x, y) => (y, x) -- evaluates to (2, 1)

Strict de la correspondance d'un tuple

Le modèle (p1, p2) est strict dans le constructeur de tuple le plus externe, ce qui peut conduire à un comportement de rigidité inattendu . Par exemple, l'expression suivante diverge (à l'aide de Data.Function.fix ):

fix $ \(x, y) -> (1, 2)

puisque la correspondance à (x, y) est stricte dans le constructeur de tuple. Cependant, l'expression suivante, utilisant un modèle irréfutable , est évaluée à (1, 2) comme prévu:

fix $ \ ~(x, y) -> (1, 2)