Haskell Language
Tuples (coppie, triple, ...)

Osservazioni

Costruisci valori di tuple

Utilizza parentesi e virgole per creare tuple. Usa una virgola per creare una coppia.

(1, 2)

Utilizzare più virgole per creare tuple con più componenti.

(1, 2, 3)

(1, 2, 3, 4)

Si noti che è anche possibile dichiarare le tuple usando nella loro forma non modificata.

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

Le tuple possono contenere valori di tipi diversi.

("answer", 42, '?')

Le tuple possono contenere valori complessi come liste o più tuple.

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

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

Scrivi i tipi di tupla

Utilizza parentesi e virgole per scrivere i tipi di tupla. Utilizzare una virgola per scrivere un tipo di coppia.

(Int, Int)

Usa più virgole per scrivere i tipi di tuple con più componenti.

(Int, Int, Int)

(Int, Int, Int, Int)

Le tuple possono contenere valori di tipi diversi.

(String, Int, Char)

Le tuple possono contenere valori complessi come liste o più tuple.

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

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

Pattern Match su Tuples

La corrispondenza del modello sulle tuple utilizza i costruttori della tupla. Ad esempio, per abbinare una coppia, useremmo il costruttore (,) :

myFunction1 (a, b) = ...

Usiamo più virgole per abbinare tuple con più componenti:

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

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

I modelli di tupla possono contenere motivi complessi come modelli di elenco o più modelli di tupla.

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

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

Estrarre i componenti della tupla

Utilizzare le funzioni fst e snd (da Prelude o Data.Tuple ) per estrarre il primo e il secondo componente di coppie.

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

O utilizzare la corrispondenza del modello.

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

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

La corrispondenza dei pattern funziona anche per le tuple con più di due componenti.

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 non fornisce funzioni standard come fst o snd per le tuple con più di due componenti. La libreria tuple su Hackage fornisce tali funzioni nel modulo Data.Tuple.Select .

Applicare una funzione binaria a una tupla (non ricorrente)

Utilizzare la funzione uncurry (da Prelude o Data.Tuple ) per convertire una funzione binaria in una funzione su tuple.

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

Applicare una funzione tupla a due argomenti (currying)

Usa la funzione curry (da Prelude o Data.Tuple ) per convertire una funzione che prende tuple a una funzione che accetta due argomenti.

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)

Scambiare i componenti della coppia

Utilizzare lo swap (da Data.Tuple ) per scambiare i componenti di una coppia.

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

O utilizzare la corrispondenza del modello.

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

Rigorosità di abbinare una tupla

Il modello (p1, p2) è rigoroso nel costruttore di tuple più esterno, che può portare a comportamenti di rigidità imprevisti . Ad esempio, la seguente espressione diverge (usando Data.Function.fix ):

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

poiché la corrispondenza su (x, y) è rigorosa nel costruttore di tuple. Tuttavia, la seguente espressione, utilizzando un modello irrefutabile , restituisce (1, 2) come previsto:

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