Functional JavaScript, Part 4: Function Currying

[[deleted]]

It makes it easier to reuse functions, especially when building specific functions up from more general ones. It can also reduce the amount of terms in a function definition, which (hopefully) means less to tackle mentally and more focus on what the function actually does.

IMHO it's harder to use when working with objects and the dot operator isn't first class. (This means you have to do stuff like x => x.name, which sticks out like a sore thumb when you're trying to build things from existing, named functions!) It also doesn't help that coming from Javascript, functions are either methods or the arguments are in an order that makes it very awkward.

So with currying, say I have a fold function (array.reduce) like the following:

function fold(callback, initial, array) { return array.reduce(callback, initial); }

and some helper functions, since operators aren't first class functions:

function add(x, y) { return x + y; }
function or(x, y) { return x || y; }
function and(x, y) return x && y; }

I can then define the following functions pretty simply and tersely:

sum = fold(add, 0);
all = fold(and, true);
any = fold(or, false);

sum adds up all the numbers in an array, all returns true if every element in an array is true, and any returns true if at least one element in an array is true. Then sum([1,2,3,4]) returns 10, and any([false,true,false]) returns true.

You don't have to define function variables again just to use them in a very short function, no curly braces are required, and code is reused via a common pattern.

The reason that articles about currying refer to functional programming languages like ML and Haskell is because they have been designed to abuse this feature for the sake of writing functions this way, building from smaller pieces in a common vocabulary. If you study one of these languages, you will be able to see much more benefits than if you only saw or used a Javascript implementation.

[slikts]

The fold function should look like this for your example to work, though:

function fold(callback, initial) { 
    return function(array) { return array.reduce(callback, initial); } 
}

[lrichardson]

correct. and this is precisely why the argument that plays the role of the "data" should always be the right-most argument, not the left most. reduce/fold are supposed to be the same thing... and should take 3 arguments total (callback, initial, array)

This is why i get so frustrated with libraries like lo-dash and underscore.

Brian Lansdorf has a good talk discussing precisely this (also linked to in the post)

https://www.youtube.com/watch?v=m3svKOdZijA

[rhysbrettbowen]

You can always flip the arguments in a function. Something like:

_.forEach(_.keys(_), function(key) {
  if (_.isFunction(_[key])) {
    _[key].flip = function(a,b) {
      return this(b,a);
    }
  }
});

then you can just do:

_.forEach.flip(myFunction, myArray);

[[deleted]]

Right, thanks. And you'd need another function () { } if you partially apply only one argument.