# Currying in Haskell

In Haskell, each function only takes one argument. Currying is used to get functions of multiple arguments.

Consider the following function:

add x y = x + y

Then, the type of `add`

is:

add :: (Num a) => a -> a -> a

which can be written:

add :: (Num a) => a -> (a -> a)

That is, `add`

takes a number as a parameter and returns a (function that takes a number and returns a function).

We can partially apply functions:

inc = add 1

Then, `inc`

is a function `\y -> 1 + y`

, because `x`

has been filled in with the value 1 that we passed as a parameter.

I think of it like this: A function takes parameters, e.g. `x`

and `y`

, and does some operations on them, e.g. `x+y`

. When I pass a value, e.g. 1, for a parameter, e.g. `x`

to a function, I am getting back a new function that will do those same operations, but with the value filled in for the dummy variable, i.e. `x`

.

## 1. How does haskell know how to partially apply user defined functions?

Functions in haskell are defined with a lot of syntactic sugar. Functions can be written as lambda expressions:

\x -> x + 3

Haskell lets us name a function:

add3 = \x -> x + 3

Syntactic sugar lets us write the function in place:

add3 x = x + 3

For multi-argument functions such as:

\x -> \y -> x + y

we can hide the currying

\x y -> x + y

and give a name as before:

add x y = x + y

This should make it clearer why Haskell knows how to interpret later calls such as `add 3`

.

## 2. What if I want to change the order of arguments?

Consider the following function:

f :: arg1 -> arg2 -> arg3 -> arg4 -> result

Then, to switch arguments 3 and 4, define `g`

:

g a b d c = f a b c d

`flip`

can do this for two arguments.

#### 2.0.1. A question about partial application

f :: Int -> Int -> Int f = \x -> if x==0 then \y -> y else \y -> 2 flip f 1

The fully applied function `flip f 1 0`

returns the same as the fully applied function `f 0 1`

, but what do the partial applications `flip f 1`

and `f 0`

look like?

#### 2.0.2. A possible answer?

Is it always the case that functions can be re-written so that the arguments come first? E.g.

f = \x -> \y -> if x==0 then y else 2

If so, then re-ordering arguments is conceptually easy to understand. I think this may be the case, but I am not sure if there exists a function which cannot be written in this form.