Haskell Language
Tupel (Paare, Tripeln, ...)

Bemerkungen

Erstellen Sie Tupelwerte

Verwenden Sie Klammern und Kommas, um Tupel zu erstellen. Verwenden Sie ein Komma, um ein Paar zu erstellen.

(1, 2)

Verwenden Sie mehr Kommas, um Tupel mit mehr Komponenten zu erstellen.

(1, 2, 3)

(1, 2, 3, 4)

Beachten Sie, dass es auch möglich ist, Tupel in ihrer ungezogenen Form zu deklarieren.

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

Tupel können Werte verschiedener Typen enthalten.

("answer", 42, '?')

Tupel können komplexe Werte enthalten, z. B. Listen oder mehr Tupel.

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

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

Schreibe Tupeltypen

Verwenden Sie Klammern und Kommas, um Tupeltypen zu schreiben. Verwenden Sie ein Komma, um einen Paartyp zu schreiben.

(Int, Int)

Verwenden Sie mehr Kommas, um Tupeltypen mit mehr Komponenten zu schreiben.

(Int, Int, Int)

(Int, Int, Int, Int)

Tupel können Werte verschiedener Typen enthalten.

(String, Int, Char)

Tupel können komplexe Werte enthalten, z. B. Listen oder mehr Tupel.

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

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

Musterübereinstimmung auf Tupeln

Der Musterabgleich auf Tupeln verwendet die Tupelkonstruktoren. Um beispielsweise ein Paar zu finden, verwenden wir den Konstruktor (,) :

myFunction1 (a, b) = ...

Wir verwenden mehr Kommas, um Tupel mit mehr Komponenten abzugleichen:

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

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

Tupelmuster können komplexe Muster enthalten, wie z. B. Listenmuster oder mehr Tupelmuster.

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

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

Extrahieren Sie die Komponenten des Tupels

Verwenden Sie die Funktionen fst und snd (aus Prelude oder Data.Tuple ), um die erste und zweite Komponente von Paaren zu extrahieren.

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

Oder verwenden Sie die Mustererkennung.

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

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

Der Musterabgleich funktioniert auch für Tupel mit mehr als zwei Komponenten.

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 bietet keine Standardfunktionen wie fst oder snd für Tupel mit mehr als zwei Komponenten. Die tuple - Bibliothek auf Hackage bietet solche Funktionen im Data.Tuple.Select Modul.

Anwenden einer binären Funktion auf ein Tupel (nicht laufend)

Verwenden Sie die Funktion uncurry (aus Prelude oder Data.Tuple ), um eine binäre Funktion in eine Funktion in Tupeln zu konvertieren.

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

Anwenden einer Tupel-Funktion auf zwei Argumente (Currying)

Verwenden Sie die curry Funktion (aus Prelude oder Data.Tuple ), um eine Funktion, die Tupel in eine Funktion überführt, die zwei Argumente Data.Tuple .

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)

Tauschen Sie Paarkomponenten

Verwenden Sie swap (aus Data.Tuple ), um die Komponenten eines Paares Data.Tuple .

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

Oder verwenden Sie die Mustererkennung.

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

Strengheit eines Tupels

Das Muster (p1, p2) ist im äußersten Tupelkonstruktor streng, was zu unerwartetem Strengeverhalten führen kann . Zum Beispiel divergiert der folgende Ausdruck (mithilfe von Data.Function.fix ):

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

da die Übereinstimmung auf (x, y) im Tupelkonstruktor streng ist. Der folgende Ausdruck wird jedoch mit einem unwiderlegbaren Muster wie erwartet zu (1, 2) ausgewertet:

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