Road to Elm - Table of Contents

If you haven't used FP languages much, you may see many little confusing things happening in Elm code.

For one, you might have found **partially applied functions**, which are functions that take *n* arguments but are called with a *less than n* number of arguments.

#### Partially Applied Functions

An example straight from the Elm Architecture tutorial #7 is:

```
(List.map (elementView address) model.gifList)
```

In this snippet `elementView`

has type `Signal.Address Action -> (Int, RandomGif.Model) -> Html`

.

It takes 2 arguments and returns `Html`

. But we're only giving it 1 argument, a `Signal.Address Action`

.

What's happening here is: any partially applied function (a function that is called with less args than it should) returns a function.

That returned function is made using the arguments that the function call got, evaluating them, and then the function you get takes the remaining number of args.

#### Example with elm-repl

Let's fire up `elm-repl`

and define `addfun : Int -> Int -> Int -> Int`

:

```
> addfun x y z = x + y + z
<function> : number -> number -> number -> number
```

So `addfun`

takes 3 args. Now let's give it 1 arg and save the resulting function in another variable:

```
> partiallyapplied1 = addfun 2
<function> : number -> number -> number
```

You can see from the type signature that the number of arguments of the function returned has diminished.

#### Javascript Equivalent

To do the same thing in Javascript would require quite a bit of wiring:

```
> var myCurriableFunction = function (x, y, z){
return function (y, z){
x + y + z;
}
}
> myCurriableFunction(2);
function (y, z){
x + y + z;
}
```

And it only supports the 1 arg case. To make a generic solution would require some more code.

#### Internals

What happens on the inside of the partially applied Elm function is:

```
> partiallyapplied1 = addfun 2
addfun 2 y z = 2 + y + z -- evaluating the x
addfun y z = 2 + y + z -- the returned function
```

Going on, applying 1 argument at a time:

```
> partiallyapplied2 = partiallyapplied1 3
<function> : number -> number
```

And so on until we finally get to a result which is not a function anymore, but a value.

```
> partiallyapplied3 = partiallyapplied2 5
10 : number
```

You can also use any of the intermediate functions we made:

```
> partiallyapplied1 3 4
9 : number
```

This in practice mean that you can give to a function in some place, only the arguments you have there. And then you can pass it to another place where you can give it the remaining arguments.

#### Why it's useful

Taking the function from the tutorial again:

```
(List.map (elementView address) model.gifList)
```

`List.map`

needs a function that takes only one argument. `elementView`

would take 2, so to use it with `List.map`

you need to partially apply it:

```
elementView : Signal.Address Action -> (Int, RandomGif.Model) -> Html
```

becomes:

```
elementView : (Int, RandomGif.Model) -> Html
```

`List.map`

can now pass each entry in `model.gifList`

which has type: `(Int, RandomGif.Model)`

to the `elementView`

function.

#### References

These concept comes from untyped lambda calculus, invented by Alonso Church.

It is common, and often fundamental, in functional languages, so it's well worth learning.

I'll probably write about Lambda Calculus in the future, and when I do I'll update this post with a link.

Bye, until next time :)

Comments? Give me a shout at @lambda_cat.

To get the latest post updates subscribe to the LambdaCat newsletter.

You can support my writing on LambdaCat's Patreon.