Currying vs Partial Application

In this post we'll cover a couple techniques in Javascript that are common among functional languages: currying and partial application. You don't need a background in functional programming to understand these, so don't worry.

A quick review about functions...

Now that you're back, let's review a couple of important points before moving ahead.

Arity refers to the number of arguments a function can accept. This might be none, one (unary), two (binary) or more (polyadic). You can also have functions that take a variable number of arguments, (variadic functions).

Functions allow you to access their arity via the .length property of the function. The .length of a function never changes - it always matches the number of declared arguments for the function.

Obviously, it's up to you and your function to properly handle the cases of too few and too many arguments.

Variadic Functions are those functions which take a variable number of arguments.

Javascript allows us to access all the arguments passed to a function via the arguments variable made available inside a function's scope. This variable contains an array-like list of all the arguments pass to the function when it was called.

I say, array-like, because even though it's a list, it only has a .length and none of the other properties you'd expect of a real Array. You can access it via indexing [], get the .length and iterate over it using a loop construct - and that's about it.

But we can convert this into a 'real' array which will make the arguments list much more useful to us:

function showArgs() {
var args = [].slice.call(arguments);
}

The [].slice.call(arguments) is a short-handed way of doing Array.prototype.slice.call(arguments), we just take advantage of the use of an array literal.

In ES6 we can access and 'unpack' our arguments even more easily with the help of the spread/gather operator:

Our curry() returns a new function that allows us to call it with one or more arguments, which it will then partially apply; up until it receives the last argument (based on the original function's arity) at which point it will return the evaluation of invoking the original function with all the arguments.

We know we can access the arity of a function using the .length property of the function. We can use this knowledge to allow us to know how many chained sequences of that function we need to call.

And, we'll need to store the original function passed in as well, so that once we have all the required arguments we can call the original function with the proper arguments and return its results.

line 2 our curry function returns a new function, in this case a named function expression called curried().

line 3 every time this function is called, we store the arguments passed to it in args

line 4 if the number of arguments is equal to the arity of the original function, we have them all, so

line 5 return the invocation of the original function with all the arguments

line 6 otherwise, return a function that will accept more arguments that, when called, will call our curried function again with the original arguments passed previously combined with the arguments passed to the newly returned function.

Excellent! This seems to do exactly what we want it to do. However, suppose we had an object with functions that depended on the proper object being set to the calling context (this) of the function. Can we use our curry function to curry an object method?

Using our curry() function as a method decorator1 seems to break the object context expected by the method. We'll have to retain the original context and be sure and pass it along to successive calls to the returned curried function.

Got it! Now our curry() function is context aware and can be used in any number of situations as a function decorator.

Currying Variadic Functions?

So our current solution works and correctly retains the context when called, as long as those functions being curried only accept exactly the number of arguments they declare - no more, no less. This doesn't help us if we want to curry a function that has optional declared arguments or a variable number of arguments (variadic functions).

With variable argument functions, we need a way to tell our curry() function when it has enough arguments to evaluate the original function that it's currying.

In the above, if we tried to use curry(max)(1)(2)(3) it evaluates too soon and we get a TypeError.

If we try to use curry(range)(1)(10) it never evaluates and simply stops by returning us a function that is still expecting another argument.

There is no feasible implementation of curry which will suffice for the example of our max() function which can take any number of arguments. Without an arity or a minimum number of arguments, there's no efficient way to determine when we should evaluate the original function with the arguments up to that point.

However, we can try to handle the case of optional, trailing arguments as in our range() example; and with minimal changes to our original curry() implementation.

We can modify our original curry() function to take an optional second argument which is the minimum number of arguments to curry.

Now, we can call curry(range, 2)(1)(10) as well as curry(range, 2)(1)(10,2). Unfortunately, though, we can't call it as curry(range, 2)(1)(10)(2), because as soon as it sees the minimum number of arguments, 2 in this case, it will return the results of evaluating the curried function.

What to do about Currying then?

It's clear from our examination above that currying in Javascript is definitely possible and useful. However, because Javascript allows any function to be variadic by nature, it becomes inefficient to implement a curry() function that can handle all possible cases.

Solution: If you're writing in a functional style, with unary and/or binary functions; and those functions take specific arguments that are declared, take advantage of currying. Otherwise, using our original implementation of curry() with the understanding that there are limitations surrounding functions with optional or variable arguments might be the best approach.

Partial Application

That was a lot of talking about currying; so, what is partial application?

Partial application means taking a function and paritally applying it to one or more of its arguments, but not all, creating a new function in the process.

The ...(spread/gather) operator and => fat arrow functions simplify the amount of code we need to implement our previous ES5 versions of curry and apply; and, I think they make the implementation more clear and understandable as well.3

You can find more references on this topic from these great posts as well.