github / keybase / email
index

# Currying

In Haskell, every function takes a single parameter. So how come you can do `max 3 6`? Or `map sqrt [1..9]`? Well there’s a trick, and it’s called currying. What happens when you do `max 3 6` is that you’re actually doing `(max 3) 6`.

We can see this by looking at its declaration:

``````max :: (Ord a) => a -> a -> a
``````

Which is the equivalent of:

``````max :: (Ord a) => a -> (a -> a)
``````

As we can see in the second declaration, the `max` function takes a single parameter of type a and returns a function that takes another parameter of type a that finally returns a value of the same type. This kind of functions are called curried functions.

Now what’s great with this is that it makes specialization really easy:

``````λ> let maxThree = max 3
λ> maxThree 5
5
λ> maxThree 2
3
λ> let mapDivByTen = map (/10)
λ> mapDivByTen [1..3]
[0.1,0.2,0.3]
``````

The second example `mapDivByTen` demonstrates the use of currying with higher order functions:

1. You first create a new function `(/10)` that takes a number and divides it by 10,
2. Then you create another function with `map` that takes a list of numbers and divides them by 10,
3. You now have a new, specialized function, that you can use on any list of numbers!

It could also be written like this:

``````λ> let divByTen = (/10)
λ> let mapDivByTen = map divByTen
``````

So currying is nice because it allows to easily create new functions on the fly (specialization!) with a clean syntax. This is especially useful when dealing with higher order functions. Also, there’s no special case: every function just takes a single argument.

Note that it differs from partial application: a curried function always takes a single parameter and always returns a function that takes a single parameter, so what you get is a chain of unary functions, whereas with partial application you can apply `n` parameters to your function and you’ll just get a function that takes `arity-n` parameters.

In Haskell, every function is curried! 🎆