Curry with JS

Partial application and currying with Javascript

In the strict way, currying is the technique of transforming a function that takes multiple arguments (a tuple of arguments) to one function that receive only one. In such way, currying techniques allow transform one multi-parameter function in a chain of functions, each one with a single argument. Looks complicated? Blah.. it is not true.
In this little article, we are actually more interesting in partial applications. Let’s take the Mozilla Example for replace function in String. As we know, we can use a “replacer” function as paramenter for replace method in String object.
Let’s say that we want to split a String defined by a non-numerical part, a numerical part and finally a non-alphanumeric part. Here is how:

function replacer(match, p1, p2, p3, offset, string){
  // p1 is nondigits, p2 digits, and p3 non-alphanumerics
  return [p1, p2, p3].join(' - ');
};

We can try it as usual…

var newString = "abc12345#$*%".replace(/([^\d]*)(\d*)([^\w]*)/, replacer);

So far so good. Let’s say now that the delimiter should change according with some conditions, e.g. locale specific.

function replacer(delimiter, match, p1, p2, p3, offset, string){
  return [p1, p2, p3].join(delimiter);
}

That’s bad. We cannot apply that replacer in regexp replace function. What can you do?
We want to have a partial application for that function. Take that!

function makeReplacer(delimiter) {
    return function replacer(match, p1, p2, p3, offset, string){
      return [p1, p2, p3].join(delimiter);
    }
}

So now, we can create a replacer for comma-separated-value:

var delimiter = ',';
var csvReplacer = makeReplacer(delimiter)

That constructor is so simple, so elementar that we could create a generic way to do that. Let’s create a curry function.

Function.prototype.curry = function() {
    var fn = this, args = Array.prototype.slice.call(arguments);
    return function() { // new function
      return fn.apply(this, args.concat(
        Array.prototype.slice.call(arguments)));
    };
  };

How does the magic work? Closure!!! That dammit word is what defined the whole magic.

var fn = this;
var args = Array.prototype.slice.call(arguments);

First, arguments is a special object to access the parameters. However, arguments type is very similar to Array but it is not an Array. To use it in apply method we need to convert it to real Array. For that, we gonna use slice function. But slice function is a method defined on Array. Ok. Ok. Let’s use the slice function from Array replacing “this” object (within slice context) by “arguments” object. with the mighty call method…

Array.prototype.slice.call(arguments);

In that way, we have this and arguments saved on context. The Closure magic will keep that context (those local variables fn and args) within the context of new function. In that new function context, we also have a new values for this variable (now keeping the new function reference) and arguments (now the arguments of that function). So we can concat (add all elements) from arguments the to our args and we gonna have all arguments necessary for the original function.

return fn.apply(this, args.concat(Array.prototype.slice.call(arguments)));};

So here we can rewrite the makeReplacer with curry… (because it is more spicy):

var delimiter = ',';
   var csvReplacer = replacer.curry(delimiter)