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!)
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
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"
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)