Haskell Language
Tuples (coppie, triple, ...)
Ricerca…
Osservazioni
Haskell non supporta le tuple con un componente in modo nativo.
Le unità (scritte
()) possono essere intese come tuple con componenti zero.Non ci sono funzioni predefinite per estrarre componenti di tuple con più di due componenti. Se ritieni di aver bisogno di tali funzioni, considera l'utilizzo di un tipo di dati personalizzato con etichette di record anziché il tipo di tupla. Quindi è possibile utilizzare le etichette dei record come funzioni per estrarre i componenti.
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)
