# Currying vs partial application

If you’re looking for an explanation of currying and partial application in JavaScript, I wrote one here.

In lambda calculus (bear with me) all functions take one argument, but you can invent some syntactic sugar to express a conceptual multi-argument function,

``foo = λx y z. x * y * z``

which can be transformed (curried) to

``bar = λx. λy. λz. x * y * z``

therefore it can be trivially partially applied (where “→” reads “evaluates to”)

``bar 1 2 → λz. 1 * 2 * z``

and finally

``bar 1 2 3 → 6``

the same is true for Haskell and ML. In JavaScript, however, all functions take any number of arguments, so you have syntax to express that already,

``var foo = function(x,y,z){ return x * y * z; };``

which can be curried (implementing the `curry` function can be a fun exercise for the reader) like this,

``var bar = function(x){ return function(y){ return function(z){ return x * y * z; }; }; };``

and therefore can be trivially partially applied

``bar(1)(2) → function(z){ return 1 * 2 * z; };``

and finally

``bar(1)(2)(3) → 6``

However, JavaScript functions can be partially applied without currying, too, with a simple implementation like

``````var partially_apply = function(){
var self = this;
var func = arguments[0];
var original_args = Array.prototype.slice.call(arguments,1);
return function(){
return func.apply(self,original_args.concat(Array.prototype.slice.call(arguments)));
}
}``````

in other words, take a function and some args to apply partially, and return a function that takes the rest of the arguments, so you can partially apply like,

``````partially_apply(foo,1,2) → function(){
return func.apply(self,[1,2].concat(Array.prototype.slice.call(arguments)));
}``````

or semantically

``partially_apply(foo,1,2) → function(z){ return 1 * 2 * z; };``

and finally

``partially_apply(foo,1,2)(3); → 6``

or if `partially_apply` is renamed to something more pretty, like `\$`,

``\$(foo,1,2)(3); → 6``

This can be very convenient for avoiding explicit anonymous functions, e.g.

``````var add = function(x,y){ return x + y; }