--- title: "Mapping more than lists" url: "https://www.bekk.christmas/post/2021/23/mapping-more-than-lists" authors: ["Eivind Dagsland Halderaker"] published: "2021-12-23" updated: "2024-11-07T13:05:28Z" language: "en-US" type: "article" tags: ["Elm", "Funksjonell"] keywords: ["Elm", "Functor"] --- # Mapping more than lists Using the function `map` to change the elements of a list has become a common pattern in modern programming languages. It is often used in Elm and `map` is also used in Elm for the Maybe and Result types. ## In short The map function does more than transform lists in Elm: it also works with Maybe and Result, applying a function to the value when one exists while leaving Nothing or Err unchanged. The article shows how mapping can change the wrapped type, and connects these examples to the Functor pattern. - **For:** Elm developers and functional programmers - **Good to know beforehand:** Basic familiarity with Elm, functions, and the List, Maybe, and Result types _AI-generated_ Using the function `map` to change the elements of a list has become a common pattern in modern programming languages. It is often used in Elm and writing a function to double all the integers in a list in Elm can be written as such ```elm doubleInts list = List.map (\number -> number * 2) list ``` As expected, running the function `doubleInts [1,2,3,4]` will return `[2,4,6,8]`. You might wonder what other types _map_ is defined for in Elm and how they operate. ## Maybe In Elm there is a type called `Maybe` which is used when a function is not guaranteed to return a proper value. A value of `Maybe` has two variants, it can either be a value, written ```elm Just value ``` or not a value, written as ```elm Nothing ``` To give an example, say you have a `String` and want to convert it into a `Float` using the function `String.toFloat`, the `String` might not represent a valid floating point number. As such, it's type signature is a `String` as parameter and `Maybe Float` as it's return type. ```elm toFloat : String -> Maybe Float ``` If given the `String` "0.5" ```elm String.toFloat "0.5" ``` it will return the value ```elm Just 0.5 ``` as "0.5" is a valid floating point number. On the other hand, if given the string "abc" ```elm String.toFloat "abc" ``` the conversion to a floating point number fails and as expected the returned value is ```elm Nothing ``` Both these value still have the type `Maybe Float` as both are valid attempts of parsing a floating point number. The `Maybe` type is common in functional programming languages, such as Haskell's `Maybe` and Scala with it's `Option`. It is used often in functional programming instead of throwing exceptions and null-values. The definition of the type `Maybe` in Elm is: ```elm type Maybe a = Just a | Nothing ``` ### Mapping a Maybe When mapping a list, each element is transformed by a given function. In the case of a `Maybe`, there is either a value or not a value, and can thought of as mapping either an list with a single element or an empty list. You're hoping there's an element inside the `Maybe` box to run the function on, however, if the `Maybe` is a `Nothing`, it will just stay as a `Nothing` after mapping the function. ## How the types change Even though mapping a function of a `Nothing` value will not change the value itself, it will still affect the type of the returned `Maybe`. Say one wants to check if the `Float` inside is greater than 5 by running ```elm Maybe.map (\float -> float > 5) maybeFloat ``` If give an actual value ```elm Maybe.map (\float -> float > 5) (Just 0.5) ``` The returned value still is a `Maybe`, but it's type has changed from `Maybe Float` to `Maybe Bool`. When given a `Nothing` ```elm Maybe.map (\float -> float > 5) Nothing ``` There is nothing to compare to, and as such the returned value will still be ```elm Nothing ``` and it's type will be `Maybe Bool`, as we tried to compare the potential floating point value to 5. The definition of `map` for a `Maybe` is ```elm map : (a -> b) -> Maybe a -> Maybe b map function maybe = case maybe of Just value -> Just (function value) Nothing -> Nothing ``` ## Result Similar to `Maybe`, Elm has a type to represent values that either succeeded or gave an error which is called `Result`. It has two variants: ```elm Ok value ``` and ```elm Err error ``` Defined in Elm as ```elm type Result error value = Ok value | Err error ``` Given that you want to parse a JSON object as a `String`, "{ "height": 5}". ```elm parseJSON : String -> Result String Int parseJSON JsonString = Decode.field "height" Decode.int ``` and check that the height is higher than 10 we can use `map` on the `Result` value ```elm higherThan10 : Result String Int -> Result String Int higherThan10 resultHeight = Result.map (\height -> height > 10) resultHeight ``` Similar to `Maybe` ```elm Result.map (\height -> height > 10) (Ok 5) ``` will return ```elm Ok False ``` and ```elm Result.map (\height -> height > 10) (Err "Failed to decode JSON object") ``` will return ```elm (Err "Failed to decode JSON object") ``` Here is the definition of map on a `Result` ```elm map : (a -> b) -> Result error a -> Result error b map function resultValue = case resultValue of Ok value -> Ok (function value) Err error -> Err error ``` ## Functors The way `map` is defined for different types is inspired by the _Functor_ design pattern in functional programming, which in turn is derived from category theory in maths. In general for a value to be a Functor it has have a function `map` with a type signature `map : (a -> b) -> f a -> f b`, where `f` is the type constructor, i. e. Maybe, Result, or List. If a functor maps the identity function, it has to return the functor unchanged.