`Tuple`

Tuples can be represented by the n-ary type constructor `Tuple`

.
The 1-element tuple Tuple a is not representable.
As an example, the type of a pair of values is `Tuple a b`

, where `a`

and `b`

are the types of the first and the second value, respectively.
The type of each component of a tuple can be distinct.

We can extract the components of a tuple using pattern matching:

```
val sumIntPair = \((m, n) : Tuple Int Int) -> m + n
val a = sumIntPair (3, 5)
// = 8
```

The 0-element tuple is representable, and Unit is just an alias to this type.

The standard library contains two functions that work with pairs (tuples of two elements): `fst`

and `snd`

:

`fst : Tuple a b -> a`

The first projection.

### Examples

```
val a = fst (0, "s")
// = 0
```

`snd : Tuple a b -> b`

The second projection.

### Examples

```
val a = snd (0, "s")
// = "s"
```

### Triples

```
val sumTriple = \((a, b, c) : Tuple Int Int Int) -> a + b + c
val x = sumTriple (1,2,3)
// = 1 + 2 + 3 = 6
```

```
val tripleToPair = \((a, b, c) : Tuple Int Int String) -> (a + b, c)
val x = tripleToPair (1, 2, "Hello")
// = (3, "Hello")
```

Tuples are a convenient way to group pieces of data in a longer computation without a need for explicitly naming the type grouping the data.

```
val f = \(x : Int) -> x + x
val g = \(y : Int) -> y * y
val xs = [1, 2, 3]
val ys = [4, 5, 6]
val combined = List::map (\(x,y) -> (f x, g y)) (List::zip xs ys)
// = [(2, 16), (4, 25), (6, 36)]
```