elm / core / Tuple

Elm has built-in syntax for tuples, so you can define 2D points like this:

origin : (Float, Float)
origin =
  (0, 0)

position : (Float, Float)
position =
  (3, 4)

This module is a bunch of helpers for working with 2-tuples.

Note 1: For more complex data, it is best to switch to records. So instead of representing a 3D point as (3,4,5) and not having any helper functions, represent it as { x = 3, y = 4, z = 5 } and use all the built-in record syntax!

Note 2: If your record contains a bunch of Bool and Maybe values, you may want to upgrade to union types. Check out Joël’s post for more info on this. (Picking appropriate data structures is super important in Elm!)

Create

pair : a -> b -> ( a, b )

Create a 2-tuple.

-- pair 3 4 == (3, 4)

zip : List a -> List b -> List (a, b)
zip xs ys =
  List.map2 Tuple.pair xs ys

Access

first : ( a, b ) -> a

Extract the first value from a tuple.

first (3, 4) == 3
first ("john", "doe") == "john"

second : ( a, b ) -> b

Extract the second value from a tuple.

second (3, 4) == 4
second ("john", "doe") == "doe"

Map

mapFirst : (a -> x) -> ( a, b ) -> ( x, b )

Transform the first value in a tuple.

import String

mapFirst String.reverse ("stressed", 16) == ("desserts", 16)
mapFirst String.length  ("stressed", 16) == (8, 16)

mapSecond : (b -> y) -> ( a, b ) -> ( a, y )

Transform the second value in a tuple.

mapSecond sqrt   ("stressed", 16) == ("stressed", 4)
mapSecond negate ("stressed", 16) == ("stressed", -16)

mapBoth : (a -> x) -> (b -> y) -> ( a, b ) -> ( x, y )

Transform both parts of a tuple.

import String

mapBoth String.reverse sqrt  ("stressed", 16) == ("desserts", 4)
mapBoth String.length negate ("stressed", 16) == (8, -16)