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.