Higher Order Functions

Higher order functions are functions that manipulate other functions.
For example, a function can take other functions as arguments and/or produce a function as its return value.
Such fancy functional techniques are powerful constructs available to you in JavaScript and other high-level languages like python, lisp, etc.

We will now create two simple functions, add_2 and double, and a higher order function called map. map will accept two arguments, func and list (its declaration will therefore begin map(func,list)), and return an array. func (the first argument) will be a function that will be applied to each of the elements in the array list (the second argument).

  1. // Define two simple functions
  2. var add_2 = function(x) {
  3.     return x + 2;
  4. };
  5. var double = function(x) {
  6.     return 2 * x;
  7. };
  9. // map is cool function that accepts 2 arguments:
  10. //  func    the function to call
  11. //  list    a array of values to call func on
  12. var map = function(func, list) {
  13.     var output=[];              // output list
  14.     for(idx in list) {
  15.         output.push( func(list[idx]) );
  16.     }
  17.     return output;
  18. }
  21. // We use map to apply a function to an entire list
  22. // of inputs to "map" them to a list of corresponding outputs
  23. map(add_2, [5,6,7]) // => [7, 8, 9]
  24. map(double, [5,6,7]) // => [10, 12, 14]

The functions in the above example are simple. However, when passed as arguments to other functions, they can be composed in unforeseen ways to build more complex functions.

For example, if we notice that we use the invocations map(add_2, ...) and map(double, ...) very often in our code, we could decide we want to create two special-purpose list processing functions that have the desired operation baked into them. Using function composition, we could do this as follows:

  1. process_add_2 = function(list) {
  2.     return map(add_2, list);
  3. }
  4. process_double = function(list) {
  5.     return map(double, list);
  6. }
  7. process_add_2([5,6,7]) // => [7, 8, 9]
  8. process_double([5,6,7]) // => [10, 12, 14]

Now let’s create a function called buildProcessor that takes a function func as input
and returns a func-processor, that is, a function that applies func to each input in list.

  1. // a function that generates a list processor that performs
  2. var buildProcessor = function(func) {
  3.     var process_func = function(list) {
  4.         return map(func, list);
  5.     }
  6.     return process_func;
  7. }
  8. // calling buildProcessor returns a function which is called with a list input
  11. // using buildProcessor we could generate the add_2 and double list processors as follows:
  12. process_add_2 = buildProcessor(add_2);
  13. process_double = buildProcessor(double);
  15. process_add_2([5,6,7]) // => [7, 8, 9]
  16. process_double([5,6,7]) // => [10, 12, 14]

Let’s look at another example.
We’ll create a function called buildMultiplier that takes a number x as input and returns a function that multiplies its argument by x :

  1. var buildMultiplier = function(x) {
  2.     return function(y) {
  3.         return x * y;
  4.     }
  5. }
  7. var double = buildMultiplier(2);
  8. var triple = buildMultiplier(3);
  10. double(3); // => 6
  11. triple(3); // => 9

{% exercise %}
Define a function named negate that takes add1 as argument and returns a function, that returns the negation of the value returned by add1. (Things get a bit more complicated ;) )
{% initial %}
var add1 = function (x) {
return x + 1;
};

var negate = function(func) {
// TODO
};

// Should return -6
// Because (5+1) * -1 = -6
negate(add1)(5);

{% solution %}
var add1 = function (x) {
return x + 1;
}

var negate = function(func) {
return function(x) {
return -1 * func(x);
}
}

negate(add1)(5);
{% validation %}
assert(negate(add1)(5) === -6);
{% endexercise %}