Functional programming: currying

Question

Writing as an unreconstructed imperative & OO programmer...

Have messed about with Erlang and also Haskell lately. I like Erlang, not sure yet about Haskell. Functional seems more like math than programming, hope that makes sense. Functional programming seems very powerful.

Reading docs on the interwibble wrt functional programming I come across the word 'currying' constantly. I seem to be finding only docs that are somewhat over my head - much terminology that is not defined.

What is currying?

I have looked for similar already posted questions but did not find anything, so feel free to point me to established thread.

TIA.

Answer 1

Currying is a way to transform functions that take multiple parameters to functions that return functions that take arguments successively. That is, to transform:

f(x, y, z)          //  (int,int,int) -> int

to

g(x)(y)(z)          //  int -> (int -> (int -> int))

in which g(x) returns another function, h(y) that takes an argument and returns j(z).

It is originated from mathematical ideas. In lambda calculus functions take a single parameter and this approach effectively enables creation of functions that take tuples.

In programming, you can use this approach to partially apply a function to some value while leaving other values undecided, and probably pass the partially applied function to another procedure to apply to actual arguments to produce return values.

Answer 2

In an algebra of functions, dealing with functions that take multiple arguments (or equivalent one argument that's an N-tuple) is somewhat inelegant -- but, as Moses Schönfinkel (and, independently, Haskell Curry) proved, it's not needed: all you need are functions that take one argument.

So how do you deal with something you'd naturally express as, say, f(x,y)? Well, you take that as equivalent to f(x)(y) -- f(x), call it g, is a function, and you apply that function to y. In other words, you only have functions that take one argument -- but some of those functions return other functions (which ALSO take one argument;-).

As usual, wikipedia has a nice summary entry about this, with many useful pointers (probably including ones regarding your favorite languages;-) as well as slightly more rigorous mathematical treatment.

Answer 3

I found this article, and the article it references, useful, to better understand currying: http://blogs.msdn.com/wesdyer/archive/2007/01/29/currying-and-partial-function-application.aspx

As the others mentioned, it is just a way to have a one parameter function.

This is useful in that you don't have to assume how many parameters will be passed in, so you don't need a 2 parameter, 3 parameter and 4 parameter functions.

Answer 4

Here's a concrete example:

Suppose you have a function that calculates the gravitational force acting on an object. If you don't know the formula, you can find it here. This function takes in the three necessary parameters as arguments.

Now, being on the earth, you only want to calculate forces for objects on this planet. In a functional language, you could pass in the mass of the earth to the function and then partially evaluate it. What you'd get back is another function that takes only two arguments and calculates the gravitational force of objects on earth. This is called currying.

Answer 5

Here's a toy example in Python:

>>> from functools import partial as curry

>>> # Original function taking three parameters:
>>> def display_quote(who, subject, quote):
        print who, 'said regarding', subject + ':'
        print '"' + quote + '"'


>>> display_quote("hoohoo", "functional languages",
           "I like Erlang, not sure yet about Haskell.")
hoohoo said regarding functional languages:
"I like Erlang, not sure yet about Haskell."

>>> # Let's curry the function to get another that always quotes Alex...
>>> am_quote = curry(display_quote, "Alex Martelli")

>>> am_quote("currying", "As usual, wikipedia has a nice summary...")
Alex Martelli said regarding currying:
"As usual, wikipedia has a nice summary..."

(Just using concatenation via + to avoid distraction for non-Python programmers.)

Editing to add:

See http://docs.python.org/library/functools.html?highlight=partial#functools.partial, which also shows the partial object vs. function distinction in the way Python implements this.