====== Elm Code ======

===== Elm patterns =====


===== Gotchas =====

==== Wrap\Unwrap ====
<code>
type Dollar = Dollar Float

priceInEuros: Dollar -> Float
priceInEuros (Dollar d) = d * 1.1

priceInEuros 3.3  -- 3.63
</code>
==== Partially applied functions ====

Every function that accepts two arguments can be converted in one that accepts one argument:
<code>
> String.repeat
<function> : Int -> String -> String

> String.repeat 4
<function> : String -> String
</code>

Then there is this:
<code>
double = (*) 2
<function> : number -> number
</code>

This can happen because all functions accept only and exactly one argument.

<code>
> greeting : String -> String -> String
| greeting greet name = greet ++ ", " ++ name ++ "!"
<function> : String -> String -> String
> greeting "Hello" "DailyDrip" == ((greeting "Hello") "DailyDrip")
True : Bool
</code>

Parentheses are optional because function evaluation associates to the left by default.

<code>
> (*)
<function> : number -> number -> number
double = (*) 2
<function> : number -> number
</code>
As we can see we can think that (*) takes two numbers as arguments. On double function the compiler will really infer that our double function takes one number as its sole argument.

Then we can easily create a function for doubling values on a list:
<code>
doubleList = List.map double
-- <function> : List number -> List number
</code>

This is the main reason why [[https://package.elm-lang.org/help/design-guidelines#the-data-structure-is-always-the-last-argument|the data structure should be always the last argument]].

He have also this:
<code>
> (|>)
<function> : a -> (a -> b) -> b

amountDeposited : List Transaction -> Float
amountDeposited list =
    List.filter (\t -> t.type_ == Deposit) list
        |> List.map .amount
        |> List.sum

-- It filters all the transactions in list which are deposits and obtain the amount for, at the last step, sum them.
-- rather than the nested equivalent:
-- List.sum (List.map .amount (List.filter (\t -> t.type_ == Deposit) list))
</code>
==== Simplify types ====
<code>
> type alias MyType = Int -> String -> String
> mytrial: MyType
| mytrial n s = String.repeat n s
<function> : Int -> String -> String
> mytrial 3 "abc"
"abcabcabc" : String
</code>