Currying is a very common little technique in functional
programming languages such as Haskell
that allow functions to return functions. (That is allow higher-order functions
to be written.)
I will now attempt to explain it, here using Haskell for the examples.
First a very simple function
Here's a function, succ, that adds one on to it's input:
succ :: int -> int
succ x = x + 1
The 'int -> int' bit says that this is a function mapping an int to an int. To apply this function you can do 'succ 1' for example, which results in 2.
Now what if you wish a function that takes more than one input? The traditional way is....
Using a Cartesian product for the domain
Here's a function that adds two numbers together:
add :: (int, int) -> int
add (x,y) = x + y
This says that 'add' is a function mapping a Cartesian product
of two ints to another int. Applying add to the ordered pair
(x,y) results in x+y. ('x+y' being the rule
of the function.)
To call the function, you would do something like:
Which (obviously enough) evaluates to 5.
Note that the brackets must be there as the function expects an ordered pair for input.
This is all well and good, except when you wish to do a function call something like:
foo0( foo1( foo2(2,4,5), foo(3) ) )
Okay, not a terribly good example, but you get the point -- there are lots of annoying parentheses about the place. One of the more mundane uses of currying is simply to reduce the number of parentheses needed.
So how does currying work?
Here's the add function again, this time done using currying:
add :: int -> (int -> int)
add a b = a + b
Now to call the function you would do:
add 2 3
Let's step back a moment; what does the signature of this new add function mean?
'int -> (int -> int)' says that the function takes a single int, and returns a function mapping an int to an int.
This works as follows:
First the 'add 2' bit is evalutated. This returns a function, which we'll name 'add2' for simplicity. Essentially this function has the definition:
add2 :: int -> int
add2 y = 2 + y
So now you're left with 'add2 3' to evaluate, which of course gives 5.
So in general....
Even if you don't understand the above waffle, just remember this. Given a function definition such as:
foo :: int -> int -> int -> int
The type after the last arrow is what the function (eventually) returns when fully evalutated.