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

Opmerkingen

Construeer tuple waarden

Gebruik haakjes en komma's om tupels te maken. Gebruik een komma om een paar te maken.

(1, 2)

Gebruik meer komma's om tuples met meer componenten te maken.

(1, 2, 3)

(1, 2, 3, 4)

Merk op dat het ook mogelijk is om tupels in hun niet-gedeelde vorm te verklaren.

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

Tupels kunnen verschillende typen waarden bevatten.

("answer", 42, '?')

Tuples kunnen complexe waarden bevatten, zoals lijsten of meer tuples.

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

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

Schrijf tuple types

Gebruik haakjes en komma's om tupletypen te schrijven. Gebruik een komma om een paartype te schrijven.

(Int, Int)

Gebruik meer komma's om tupletypen met meer componenten te schrijven.

(Int, Int, Int)

(Int, Int, Int, Int)

Tupels kunnen verschillende typen waarden bevatten.

(String, Int, Char)

Tuples kunnen complexe waarden bevatten, zoals lijsten of meer tuples.

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

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

Patroonovereenkomst op Tuples

Patroonaanpassing op tupels maakt gebruik van de tuple-constructors. Om bijvoorbeeld een paar te matchen, gebruiken we de constructor (,) :

myFunction1 (a, b) = ...

We gebruiken meer komma's om tupels met meer componenten te matchen:

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

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

Tupelpatronen kunnen complexe patronen bevatten, zoals lijstpatronen of meer tuplepatronen.

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

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

Extraheer tuple componenten

Gebruik de functies fst en snd (van Prelude of Data.Tuple ) om de eerste en tweede component van paren te extraheren.

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

Of gebruik patroonafstemming.

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

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

Patroonaanpassing werkt ook voor tupels met meer dan twee componenten.

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 biedt geen standaardfuncties zoals fst of snd voor tupels met meer dan twee componenten. De tuple bibliotheek op Hackage biedt dergelijke functies in de Data.Tuple.Select module.

Een binaire functie toepassen op een tuple (niet-scheurend)

Gebruik de uncurry functie (van Prelude of Data.Tuple ) om een binaire functie om te zetten in een functie op tupels.

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

Een tuple-functie toepassen op twee argumenten (currying)

Met de curry functie (bij Prelude of Data.Tuple ) een functie die tupels is om een functie die twee argumenten neemt zetten.

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)

Wissel paar componenten

Gebruik swap (van Data.Tuple ) om de componenten van een paar te wisselen.

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

Of gebruik patroonafstemming.

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

Striktheid van het matchen van een tuple

Het patroon (p1, p2) is streng in de buitenste tuple-constructor, wat kan leiden tot onverwacht striktheidsgedrag . De volgende expressie wijkt bijvoorbeeld af (met behulp van Data.Function.fix ):

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

omdat de match op (x, y) strikt is in de tuple-constructor. De volgende expressie wordt echter, volgens een onweerlegbaar patroon , geëvalueerd als (1, 2) zoals verwacht:

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