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

Anmärkningar

Konstruera tupelvärden

Använd parenteser och kommatecken för att skapa tuples. Använd ett komma för att skapa ett par.

(1, 2)

Använd fler komma för att skapa tupler med fler komponenter.

(1, 2, 3)

(1, 2, 3, 4)

Observera att det också är möjligt att deklarera tuples som används i sin unsugared form.

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

Tuples kan innehålla värden av olika typer.

("answer", 42, '?')

Tuples kan innehålla komplexa värden som listor eller fler tuples.

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

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

Skriv typstyper

Använd parenteser och kommatecken för att skriva typtyper. Använd ett komma för att skriva en partyp.

(Int, Int)

Använd fler kommatecken för att skriva tupeltyper med fler komponenter.

(Int, Int, Int)

(Int, Int, Int, Int)

Tuples kan innehålla värden av olika typer.

(String, Int, Char)

Tuples kan innehålla komplexa värden som listor eller fler tuples.

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

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

Mönster match på tuples

Mönstermatchning på tuples använder tupelkonstruktörerna. För att matcha ett par till exempel, skulle vi använda (,) konstruktören:

myFunction1 (a, b) = ...

Vi använder fler komma för att matcha tuples med fler komponenter:

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

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

Tupelmönster kan innehålla komplexa mönster som listmönster eller fler tupelmönster.

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

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

Extrahera tupelkomponenter

Använd fst och snd funktionerna (från Prelude eller Data.Tuple ) för att extrahera den första och andra komponenten i par.

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

Eller använd mönstermatchning.

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

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

Mönstermatchning fungerar också för tupler med mer än två komponenter.

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 tillhandahåller inte standardfunktioner som fst eller snd för tupler med mer än två komponenter. tuple biblioteket på Hackage tillhandahåller sådana funktioner i Data.Tuple.Select modulen.

Tillämpa en binär funktion på en tupel (uncurrying)

Använd den uncurry funktionen (från Prelude eller Data.Tuple ) för att konvertera en binär funktion till en funktion på 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

Använd en tuple-funktion på två argument (currying)

Använd curry (från Prelude eller Data.Tuple ) för att konvertera en funktion som tar tuples till en funktion som tar två argument.

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)

Byt parkomponenter

Använd swap (från Data.Tuple ) för att byta komponenter i ett par.

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

Eller använd mönstermatchning.

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

Strikthet med att matcha en tupel

Mönstret (p1, p2) är strikt i den yttersta tupelkonstruktören, vilket kan leda till oväntat strikt uppförande . Till exempel avviker följande uttryck (med Data.Function.fix ):

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

eftersom matchen på (x, y) är strikt i tupelkonstruktören. Följande uttryck, med användning av ett oåterkalleligt mönster , utvärderar emellertid till (1, 2) som förväntat:

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