Take the 2-minute tour ×

I'm not exactly sure how to word this question.

I learnt what currying was in the first year of university, and have been using it where applicable ever since.

However, I quite often see on the Internet various complaints that other peoples examples of currying are not currying, but are actually just partial application.

I've not found a decent explanation of what partial application is, or how it differs from currying. There seems to be a general confusion, with equivalent examples being described as currying in some places, and partial application in others.

Could someone provide me with a definition of both terms, and details of how they differ?

share|improve this question

8 Answers 8

up vote 122 down vote accepted

Currying is converting a single function of n arguments into n functions with a single argument each. Given the following function:

function f(x,y,z) { z(x(y));}

When curried, becomes:

function f(x) { lambda(y) { lambda(z) { z(x(y)); } } }

In order to get the full application of f(x,y,z), you need to do this:


Many functional languages let you write f x y z. If you only call f x y or f(x)(y) then you get a partially-applied function—the return value is a closure of lambda(z){z(x(y))} with passed-in the values of x and y to f(x,y).

One way to use partial application is to define functions as partial applications of generalized functions, like fold:

function fold(combineFunction, accumalator, list) {/* ... */}
function sum     = curry(fold)(lambda(accum,e){e+accum}))(0);
function length  = curry(fold)(lambda(accum,_){1+accum})(empty-list);
function reverse = curry(fold)(lambda(accum,e){concat(e,accum)})(empty-list);

/* ... */
@list = [1, 2, 3, 4]
sum(list) //returns 10
@f = fold(lambda(accum,e){e+accum}) //f = lambda(accumaltor,list) {/*...*/}
f(0,list) //returns 10
@g = f(0) //same as sum
g(list)  //returns 10
share|improve this answer
You're saying that partial application is when you curry a function, and use some, but not all of the resulting functions? –  SpoonMeiser Oct 20 '08 at 11:22
more or less, yes. If you only supply a subset of the arguments, you'll get back a function that accepts the rest of the arguments –  Mark Cidade Oct 20 '08 at 11:27
Would changing a function f(a, b, c, d) to g(a, b) count as partial application? Or is it only when applied to curried functions? Sorry to be a pain, but I'm angling for an explicit answer here. –  SpoonMeiser Oct 20 '08 at 11:34
@Mark: I guess this is just one of those concepts that brings out the pedant in me - but an appeal to authoritative sources does little to satisfy, since they all seem to point to one another. Wikipedia is hardly what I consider an authoritative source, but I understand that it's hard to find much else. Suffice it to say that I think we both know that of which we speak and the power thereof, regardless of whether or not we can agree (or disagree) on the particulars of the vernacular! :) Thanks Mark! –  Jason Bunting Aug 9 '10 at 18:13
@JasonBunting, Regarding your first comment, what you were talking about is decurrying. Currying is taking a multi-arg function as input and returning a chain of 1-arg functions as output. De-currying is taking a chain of 1-arg functions as input and returning a multi-arg function as output. As elaborated on stackoverflow.com/a/23438430/632951 –  Pacerier May 2 '14 at 23:43

The easiest way to see how they differ is to consider a real example. Let's assume that we have a function Add which takes 2 numbers as input and returns a number as output, e.g. Add(7, 5) returns 12. In this case:

  • Partial applying the function Add with a value 7 will give us a new function as output. That function itself takes 1 number as input and outputs a number. As such:

    Partial(Add, 7); // returns a function f2 as output
                     // f2 takes 1 number as input and returns a number as output

    So we can do this:

    f2 = Partial(Add, 7);
    f2(5); // returns 12;
           // f2(7)(5) is just a syntactic shortcut
  • Currying the function Add will give us a new function as output. That function itself takes 1 number as input and outputs yet another new function. That third function then takes 1 number as input and returns a number as output. As such:

    Curry(Add); // returns a function f2 as output
                // f2 takes 1 number as input and returns a function f3 as output
                // i.e. f2(number) = f3
                // f3 takes 1 number as input and returns a number as output
                // i.e. f3(number) = number

    So we can do this:

    f2 = Curry(Add);
    f3 = f2(7);
    f3(5); // returns 12

In other words, "currying" and "partial application" are two totally different functions. Currying takes exactly 1 input, whereas partial application takes 2 (or more) inputs.

Even though they both return a function as output, the returned functions are of totally different forms as demonstrated above.

share|improve this answer
+1. Best explanation on the web, IMO. –  Ben Collins Aug 27 '14 at 16:13
Crystal clear:) –  LiweiZ Dec 21 '14 at 22:42
a rating of: ✰✰✰✰✰ –  t q Jan 9 at 3:34

Note: this was taken from F# Basics an excellent introductory article for .NET developers getting into functional programming.

Currying means breaking a function with many arguments into a series of functions that each take one argument and ultimately produce the same result as the original function. Currying is probably the most challenging topic for developers new to functional programming, particularly because it is often confused with partial application. You can see both at work in this example:

let multiply x y = x * y    
let double = multiply 2
let ten = double 5

Right away, you should see behavior that is different from most imperative languages. The second statement creates a new function called double by passing one argument to a function that takes two. The result is a function that accepts one int argument and yields the same output as if you had called multiply with x equal to 2 and y equal to that argument. In terms of behavior, it’s the same as this code:

let double2 z = multiply 2 z

Often, people mistakenly say that multiply is curried to form double. But this is only somewhat true. The multiply function is curried, but that happens when it is defined because functions in F# are curried by default. When the double function is created, it’s more accurate to say that the multiply function is partially applied.

The multiply function is really a series of two functions. The first function takes one int argument and returns another function, effectively binding x to a specific value. This function also accepts an int argument that you can think of as the value to bind to y. After calling this second function, x and y are both bound, so the result is the product of x and y as defined in the body of double.

To create double, the first function in the chain of multiply functions is evaluated to partially apply multiply. The resulting function is given the name double. When double is evaluated, it uses its argument along with the partially applied value to create the result.

share|improve this answer

Interesting question. After a bit of searching, "Partial Function Application is not currying" gave the best explanation I found. I can't say that the practical difference is particularly obvious to me, but then I'm not an FP expert...

Another useful-looking page (which I confess I haven't fully read yet) is "Currying and Partial Application with Java Closures".

It does look like this is widely-confused pair of terms, mind you.

share|improve this answer
Interesting links, although they do offer conflicting ideas of what currying is. –  SpoonMeiser Oct 20 '08 at 11:13
The first link is spot-on about the differences. Here's another one I found useful: bit.ly/CurryingVersusPartialApplication –  Jason Bunting Jul 21 '10 at 23:27
Currying is to do with tuples (turning a function that takes a tuple argument into one that takes n separate arguments, and vice versa). Partial application is the ability to apply a function to some arguments, yielding a new function for the remaining arguments. It is easy to remember if you just think currying == to do with tuples. –  Don Stewart Sep 11 '12 at 11:38
@Jon links you posted are informative, but it will be better to expand your answer and add some more info here. –  Zaheer Ahmed Oct 28 '14 at 7:29
@Zaheer: This answer is over 6 years old, and the other answers already cover it. I don't think there's much to be gained from expanding this now. –  Jon Skeet Oct 28 '14 at 8:06

I have answered this in another thread http://stackoverflow.com/a/12846865/1685865 . In short, partial function application is about fixing some arguments of a given multivariable function to yield another function with fewer arguments, while Currying is about turning a function of N arguments into a unary function which returns a unary function...[An example of Currying is shown at the end of this post.]

Currying is mostly of theoretical interest: one can express computations using only unary functions (i.e. every function is unary). In practice and as a byproduct, it is a technique which can make many useful (but not all) partial functional applications trivial, if the language has curried functions. Again, it is not the only means to implement partial applications. So you could encounter scenarios where partial application is done in other way, but people are mistaking it as Currying.

(Example of Currying)

In practice one would not just write

lambda x: lambda y: lambda z: x + y + z

or the equivalent javascript

function (x) { return function (y){ return function (z){ return x + y + z }}}

instead of

lambda x, y, z: x + y + z

for the sake of Currying.

share|improve this answer
Would you say that currying is a specific case of partial application then? –  SpoonMeiser Nov 7 '12 at 11:16
@SpoonMeiser, No, currying is not a specific case of partial application: A partial application of a 2-input function is not the same as currying the function. See stackoverflow.com/a/23438430/632951 . –  Pacerier May 2 '14 at 23:32

The difference between curry and partial application can be best illustrated through this following JavaScript example:

function f(x, y, z) {
    return x + y + z;

var partial = f.bind(null, 1);

6 === partial(2, 3);

Partial application results in a function of smaller arity; in the example above, f has an arity of 3 while partial only has an arity of 2. More importantly, a partially applied function would return the result right away upon being invoke, not another function down the currying chain. So if you are seeing something like partial(2)(3), it's not partial application in actuality.

Further reading:

share|improve this answer

For me partial application must create a new function where the used arguments are completely integrated into the resulting function.

Most functional languages implement currying by returning a closure: do not evaluate under lambda when partially applied. So, for partial application to be interesting, we need to make a difference between currying and partial application and consider partial application as currying plus evaluation under lambda.

share|improve this answer

In writing this, I confused currying and uncurrying. They are inverse transformations on functions. It really doesn't matter what you call which, as long as you get what the transformation and its inverse represent.

Uncurrying isn't defined very clearly (or rather, there are "conflicting" definitions that all capture the spirit of the idea). Basically, it means turning a function that takes multiple arguments into a function that takes a single argument. For example,

(+) :: Int -> Int -> Int

Now, how do you turn this into a function that takes a single argument? You cheat, of course!

plus :: (Int, Int) -> Int

Notice that plus now takes a single argument (that is composed of two things). Super!

What's the point of this? Well, if you have a function that takes two arguments, and you have a pair of arguments, it is nice to know that you can apply the function to the arguments, and still get what you expect. And, in fact, the plumbing to do it already exists, so that you don't have to do things like explicit pattern matching. All you have to do is:

(uncurry (+)) (1,2)

So what is partial function application? It is a different way to turn a function in two arguments into a function with one argument. It works differently though. Again, let's take (+) as an example. How might we turn it into a function that takes a single Int as an argument? We cheat!

((+) 0) :: Int -> Int

That's the function that adds zero to any Int.

((+) 1) :: Int -> Int

adds 1 to any Int. Etc. In each of these cases, (+) is "partially applied".

share|improve this answer

Your Answer


