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 higher order

var add_2 = function(x) {

return x + 2;

};

var map = function(func, list) {

var output=[]; // output list

for(idx in list) {

output.push( func(list[idx]) );

}

return output;

}

map(add_2, [5,6,7]) // => [7, 8, 9]

map(double, [5,6,7]) // => [10, 12, 14]

The functions in the above example were intentionally simple,

and serves to illustrate that passing functions as arguments

to other functions allows for flexibility when building things.

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-purpse list processors that have the desired operation baked into them. Using function composition, we could do this as follows:

process_add_2 = function(list) {

return map(add_2, list);

}

process_double = function(list) {

return map(double, list);

}

process_add_2([5,6,7]) // => [7, 8, 9]

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.

var buildProcessor = function(func) {

var process_func = function(list) {

return map(func, list);

}

return process_func;

process_add_2 = buildProcessor(add_2);

process_double = buildProcessor(double);

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 it's argument by x :