Haskell Language
Krotki (pary, trójki, ...)

Uwagi

Skonstruuj wartości krotek

Do tworzenia krotek używaj nawiasów i przecinków. Użyj jednego przecinka, aby utworzyć parę.

(1, 2)

Użyj więcej przecinków, aby utworzyć krotki z większą liczbą składników.

(1, 2, 3)

(1, 2, 3, 4)

Zauważ, że możliwe jest również deklarowanie krotek za pomocą ich niezabezpieczonej postaci.

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

Krotki mogą zawierać wartości różnych typów.

("answer", 42, '?')

Krotki mogą zawierać złożone wartości, takie jak listy lub więcej krotek.

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

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

Napisz typy krotek

Używaj nawiasów i przecinków, aby pisać typy krotek. Użyj jednego przecinka, aby wpisać typ pary.

(Int, Int)

Użyj więcej przecinków, aby napisać typy krotek z większą liczbą składników.

(Int, Int, Int)

(Int, Int, Int, Int)

Krotki mogą zawierać wartości różnych typów.

(String, Int, Char)

Krotki mogą zawierać złożone wartości, takie jak listy lub więcej krotek.

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

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

Dopasuj wzór w krotkach

Dopasowywanie wzorców w krotkach używa konstruktorów krotek. Aby na przykład dopasować parę, użylibyśmy konstruktora (,) :

myFunction1 (a, b) = ...

Używamy więcej przecinków, aby dopasować krotki z większą liczbą składników:

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

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

Wzory krotkowe mogą zawierać złożone wzorce, takie jak wzorce listowe lub więcej wzorców krotkowych.

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

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

Wyodrębnij składniki krotek

Użyj funkcji fst i snd (z Prelude lub Data.Tuple ), aby wyodrębnić pierwszy i drugi składnik par.

fst (1, 2) -- evaluates to 1

snd (1, 2) -- evaluates to 2

Lub użyj dopasowania wzorca.

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

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

Dopasowywanie wzorców działa również w krotkach z więcej niż dwoma komponentami.

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 nie zapewnia standardowych funkcji takich jak fst lub snd dla krotek z więcej niż dwoma komponentami. Biblioteka tuple w Hackage zapewnia takie funkcje w module Data.Tuple.Select .

Zastosuj funkcję binarną do krotki (unurrying)

Użyj funkcji uncurry (z Prelude lub Data.Tuple ), aby przekonwertować funkcję binarną na funkcję w krotkach.

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

Zastosuj funkcję krotki do dwóch argumentów (curry)

Użyj funkcji curry (z Prelude lub Data.Tuple ), aby przekonwertować funkcję pobierającą krotki na funkcję, która pobiera dwa argumenty.

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)

Zamień pary komponentów

Użyj swap (z Data.Tuple ), aby zamienić składniki pary.

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

Lub użyj dopasowania wzorca.

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

Dokładność dopasowania krotki

Wzorzec (p1, p2) jest ścisły w zewnętrznym konstruktorze krotek, co może prowadzić do nieoczekiwanego zachowania ścisłości . Na przykład następujące wyrażenie jest rozbieżne (przy użyciu Data.Function.fix ):

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

ponieważ dopasowanie na (x, y) jest ścisłe w konstruktorze krotki. Jednak następujące wyrażenie, używając niepodważalnego wzorca , ocenia na (1, 2) zgodnie z oczekiwaniami:

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