# Curry? #

Currying is a technique that translates a function of arity N into a sequence of functions that all have the arity 1. Function arity means the number of arguments a function takes.

``````# The add function has the arity of 2
add = fn x, y -> x + y end
``````

The term curry/currying was coined back in the 60s referring to the logician Haskell Curry. The programming language named after him has curried functions built in, and many other languages have implemented the same kind of behavior via libraries.

# Implementing currying in Elixir #

Elixir is a functional language, but unlike Haskell, it does not have built in function currying.

In Haskell we could do this

``````let add x y = x + y -- add is curried by default
increment 3 -- returns 4
``````

## A naive approach #

Elixir functions are first class, so your function can return them and receive them as values.

``````add = fn x ->
fn y -> x + y end
end
``````

``````increment = add.(1)
increment.(3) # => returns 4
``````

This works, but its obvious that we want something more general, and reusable. In fact the above could be considered a plain function that is partially applied.

## We can do better #

Again, Elixir being a fantastic language has tools we can use to make a more general solution. To get the job done we will use pattern matching, and recursion.

In the first paragraphs we talked about arity. Arity is very important in Elixir and Erlang. The language actually considers functions with the same name, but with different arity completely different functions. This is why you see a slash followed by an integer e.g. `some_function/2` in various places in the language documentation.

## Lets build our own curry function #

### curry/1 #

The first function our curry implementation needs is the starting point, here our function has the arity of 1.

The `:erlang` atom lets you call Erlang code (calls are zero cost), here we gather information about the function that is to be curried, using pattern matching we only care about the second returned value, omitting the first with `_` so the compiler wont yell at us for unused variables. Finally we call the curry function again, but this time with a different arity.

`````` def curry(fun) do
{_, arity} = :erlang.fun_info(fun, :arity)
curry(fun, arity, [])
end
``````

### curry/3 #

This time our curry function has the arity of 3. We receive the function that is to be curried, the function arity and arguments. The arguments is just a empty list in the first call.

This function will return a function, taking an argument `arg` and recurse on itself decrementing the variable arity by one. The `arity` variable is often called an accumulator, and is widely used in recursive functions. Finally the last argument that was originally an empty list will be filled with the supplied argument.

``````  def curry(fun, arity, arguments) do
fn arg -> curry(fun, arity - 1, [arg | arguments]) end
end
``````

### curry/3 #

Stop! Wasn’t functions in Elixir supposed to distinguished by name and arity? So how can Elixir distinguish two functions with the same name and the same arity?

To find out we can test how Elixir calls functions

``````defmodule Callme do

def im_unique {:unique, "callme"} do
IO.puts "Ring ring"
end

def im_unique {:unique, "callyou"} do
end

end

Callme.im_unique {:unique, "callme"} # => Ring ring
``````

Both functions have the same name, same arity and even accepts the same type of input. Still there a small difference, the tuple is not the same. So we can conclude that pattern matching is used in function invocation.

Lets build the final piece of our curry function.

When the second curry function has recursed as many times as the original function that we wanted to curry had as arity the pattern no longer matches, and Elixir will match the last curry function. The arity parameter is now down to `0` and we can apply the original function to the arguments.

Because we have recursed the parameters we will need to reverse the list so we dont mess up the original order of the parameters the user has passed in. The `fun` function will have the same arity as the number of items collected in the arguments list.

`````` def curry(fun, 0, arguments) do
apply(fun, Enum.reverse arguments)
end
``````

## Putting it all together #

Lets have the code in one place, and test it out!

``````defmodule Curry do

def curry(fun) do
{_, arity} = :erlang.fun_info(fun, :arity)
curry(fun, arity, [])
end

def curry(fun, 0, arguments) do
apply(fun, Enum.reverse arguments)
end

def curry(fun, arity, arguments) do
fn arg -> curry(fun, arity - 1, [arg | arguments]) end
end

end
``````

Lets see how to use our curry function.

``````import Curry

curried = curry(fn a, b, c, d -> a * b + div(c, d) end)

# => #Function<0.122306914/1 in Curry.curry/3>
# We get a function back!
# Lets apply some params!

curried.(5).(5).(10).(2)
# => 30
# We get a result when all params are passed!

five_squared = curried.(5).(5)
five_squared_plus_five = five_squared.(10).(2)
# => 30
# We get a result!
``````

## A few more examples #

By currying functions you can build small reusable functions that are really simple to test, and reason about.

``````defmodule Curried do

import Curry

def match term do
curry(fn what -> (Regex.match?(term, what)) end)
end

def filter f do
curry(fn list -> Enum.filter(list, f) end)
end

def replace what do
curry(fn replacement, word ->
Regex.replace(what, word, replacement)
end)
end

end
``````
``````# Match when there is a space
has_spaces = Curried.match(~r/\s+/)

# Reuse has_spaces in our filter
sentences = Curried.filter(has_spaces)

disallowed = Curried.replace(~r/[jruesbtni]/)

# Insert censor token
censored = disallowed.("*")

# Pass the arguments to the curried function
allowed = sentences.(["justin bibier", "and sentences", "are", "allowed"])
# => returns ["justin bibier", "and sentences"]

# Pipe the first sentence and apply the censor
allowed |> List.first |> censored.() # => returns "****** ******"
``````

As you see currying makes it very simple to reuse functions, and build up higher order functions. In Elixir its even more elegant than in most other languages because you can use the pipe operator to chain functions.