--- title: "Once, twice, three times a value" url: "https://www.bekk.christmas/post/2020/01/once-twice-three-times-a-value" authors: ["Jørgen Tu Sveli"] published: "2020-12-01" updated: "2024-11-07T13:05:29Z" language: "en-US" type: "article" tags: ["Elm"] --- # Once, twice, three times a value Welcome to the Elm christmas calendar, and to the first of 24 articles that will teach you some tricks and useful concepts you might not already know. Today we are discussing Tuples. It is perhaps Elm's simplest way of structuring data. We also introduce a concept recurring across several days; pattern matching, or destructuring. The first use-case is pattern matching of tuples in function declarations. ## In short Elm tuples bundle up to three values into a single value, with the tuple’s type determined by the types and order of its elements. Pattern matching can unpack tuples directly in function parameters, and the core Tuple helpers like first use the same idea to extract values. - **For:** Elm developers - **Good to know beforehand:** Basic familiarity with Elm functions and types _AI-generated_ Tuples allow us to join values together into a single value. Elm, as of version 0.19, allows tuples of no more than 3 values. A function can receive a tuple as an argument or it can return one. The latter enables returning more than one value from a function. This requires more work in languages without tuples. Here are som tuples: ```elm governator : ( String, Int ) governator = ("Arnie", 73) -- A 2-Tuple numbers : ( Int, Int, Int ) numbers = ( 12, 24, 18 ) -- A 3-tuple ``` The core module `Tuple` has helper functions for working with 2-tuples. E.g. `Tuple.first` and `Tuple.second` extract the respective values. ```elm Tuple.first person -- 23 ``` The pattern of types of its values make up the tuple's type as a whole. Hence, a tuple of String and Int cannot serve as a tuple of Int and String. ## Pattern matching tuples In a function that takes a tuple, there are two main ways of "receiving" the argument. Receiving the tuple as a single value is the straightforward approach. ```elm canDrive: (Bool, Bool) -> String canDrive ageAndLicenseStatus = let oldEnough = Tuple.first ageAndLicenseStatus hasLicense = Tuple.second ageAndLicenseStatus in if oldEnough && hasLicense then "Allowed to drive" else "Not allowed to drive" ``` Pattern matching the received tuple debloats the code considerably. ```elm canDrive: (Bool, Bool) -> String canDrive (oldEnough, hasLicense) = if oldEnough && hasLicense then "Allowed to drive" else "Not allowed to drive" ``` Pattern matching still works if you introduce a type alias for your tuple. ```elm type alias DrivingRequirements = (Bool, Bool) canDrive: DrivingRequirements -> String canDrive (oldEnough, hasLicense) = -- ... ``` ## A look at core/Tuple After establishing a basic understanding of a concept, I find it rewarding to look at API source code related to that concept. We saw how we could use `Tuple.first` to extract the first value from a tuple. Here is its [source code](https://github.com/elm/core/blob/master/src/Tuple.elm). ```elm first : (a, b) -> a first (x,_) = x ``` Reading these type signatures can feel daunting at first. But let's apply what we know about tuples and how `first` works. Regarding the type annotation, `(a, b)` merely states that `first` takes a tuple of two values that might not be the same type. The return type is `a`, referring to the type of the first element of the incoming tuple. The type declaration is telling us: "I take a tuple of two values and return whatever type the tuple's first value had". In line 2, we see that `first` makes use of pattern matching, albeit with a twist. `first` only needs the first value. The second value need not be named, but must be matched using the placeholder `_`. ## Conclusion / TLDR Elm has built-in syntax for creating tuples to structure data. When receiving a tuple as a parameter a similar syntax can be used to extract the tuple's values into separate variables. Heeding the notes in [core/Tuple](https://package.elm-lang.org/packages/elm/core/latest/Tuple) is advisable. When you need a little complexity in your data structure, tuples are rarely the right choice. ## Relevant resources recommended by the author - [core/Tuple](https://package.elm-lang.org/packages/elm/core/latest/Tuple)