## Curried functions

Een functie kan een andere functie teruggeven.

```haskell
add' :: Int -> (Int -> Int)
add' x y = x+y
```

Hier, is **add'** functie die een **Int** als argument neemt en resulteerd in een functie van het type: **Int -> Int**.
De functie definitie neemt een integer **x**, gevolgd door integer **y**, die kan worden [ge-curried](https://en.wikipedia.org/wiki/Currying).

```haskell
addThree = add' 3  -- Dit is nu een functie met type: Int -> Int
result = addThree 5  -- Resulteerd in 8
```

Nog een voorbeeld

```haskell
mult :: Int -> (Int -> (Int -> Int))
mult x y z = x*y*z
```

En toegepast:

```haskell
mult x y z
-- Hetzelfde als:
((mult x) y) z
```

Als deze wordt gebruikt, kan dat zo:

```haskell
multTwo = mult 2   -- Dit is nu een functie met type: Int -> (Int -> Int)
multTwoThree = multTwo 3  -- Dit is is: Int -> Int
result = multTwoThree 4  -- Resulteerd in: 2 * 3 * 4 = 24

-- of gewoon:

result = mult 2 3 4  -- Resulteerd ook in 24
```

**Partial application** is het gebruiken van curried functies, door enkele argumenten te geven en een functie terug te krijgen.

```haskell
double = mult 2   -- Dit is nu een functie met type: Int -> (Int -> Int)

result = double 3 4  -- Resulteerd in: 2 * 3 * 4 = 24

quadruple = double 2  -- quadruple :: Int -> Int
result = quadruple 3  -- Resulteerd in: 2 * 2 * 3 = 12
```

De pijl **->** in Haskell types associeerd vanaf rechts.

```haskell
Int -> Int -> Int -> Int

-- is:

Int -> (Int -> (Int -> Int))
```

Tenzij tuples nodig zijn, zijn alle functies in Haskell met meerdere argumenten eigenlijk curried functies, met een manier om de vele haakjes weg te kunnen laten.
