Higher-Order Functions in JavaScript

Higher-order functions in Javascript

1. Boolean is a function. It's the function you're calling indirectly through noisy. A bit confusing, I know, because it looks like the name of a type. But in JavaScript, those initially-capped things (Boolean, Number, String, and so on) are functions. When you call Boolean (without using new), it tries to convert the argument you gave it into a boolean primitive value and returns the result. (See §15.6.1 in the spec.)

2. f is the name of the argument in the noisy function.

Functions in JavaScript are first-class objects. You can pass them into other functions as arguments just like any other object.

When you do

noisy(Boolean)(0)

There are two things going on. First:

// (In effect, we're not really creating a variable...)
var x = noisy(Boolean);

That gives us a function that, when called, will call Boolean with the argument we give it while also doing those console.log statements. This is the function you see being created in noisy (return function(arg)...);

Then we call that function:

x(0);

And that's when you see the console output. Since Boolean(0) is false, you see Boolean return that value.

Here's a much simpler example:

function foo(bar) {
    bar();
}
function testing() {
    alert("testing got called");
}
foo(testing);

There, I'm passing the function testing into foo. The argument name I'm using for that within foo is bar. The line bar(); calls the function.

Learn Javascript : Higher Order Function

Higher order function are functions that take other functions as parameter(s). It is based on functions being so-called first-class-members in Javascript, which says, among other things, this: functions can be passed to other functions, as parameters.

In your example the passed function inside the repeatfunction is called action, which is defined by your repeat function signature (n,action) (regardless of any name the actual function that is being passed in might already have), so whatever function gets passed into repeat is callable inside it using action().

Please note that there is no way to guarantee that the actual call will have a function as a second parameter; noone can prevent somebody from making calls like repeat('foo', 'bar') or even repeat(). It is your job as a developer to make your function failsafe in this regard, or to take the shit in, shit out standpoint.

A more simplified example would be this:

function showMessage(message, showMethod) {
  showMethod(message);
}

showMessage('Hello world shown by console.log', console.log);

showMessage('Hello world shown by alert', alert);

showMessage('Hello world shown by console.error', console.error);

Javascript :higher order functions

You need to filter the values which return true for the callback and collect all other values and return a new array with the values from filtering and the other collected values.

const partition = function(arr, callback) { // IMPLEMENT ME
    const array = [];
    return [
        arr.filter(value => {
            if (callback(value)) return true;
            array.push(value);
        }),
        array
    ];
};

console.log(partition([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], n => n % 2 === 0)); // [[2, 4, 6, 8, 10], [1, 3, 5, 7, 9]]

console.log(partition([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5], n => n < 0)); // [[-5, -4, -3, -2, -1], [0, 1, 2, 3, 4, 5]]

Understanding higher order JavaScript functions

What is higher order function ?

Functions that operate on other functions, either by taking them as
arguments or by returning them, are called higher-order functions.

Let me start with a small example and then we get back to the problem in the question.

function evenNumberFilter(number) {
  return number%2==0
}

function oddNumberFilter(number) {
  return !evenNumberFilter(number)
}

evenNumberFilter(2) // true
oddNumberFilter(3)  // true

Are closures higher order functions?

A closure does not mean that it necessarily is returned by a function. In JavaScript every function actually is a closure. A closure generally is a function that has access to the declaration context's scope.

function outer(lastName){  const name = 'Bob';
  function inner(lastName)  {    // here we have access to the outer function's scope    // thus it IS a closure regardless whether we return the function or not    console.log(name + ' ' + lastName);  }    inner(lastName);}
outer('Marley');

Optional arguments for higher-order functions

It's not possible in general to have a function with a variable number of arguments, but it is possible to pass either undefined or a value, which in most cases will be equivalent.

One way to do so is to simply use the option type. If we re-define next as

type next = (. option<int>) => unit 

we can use it like this

io->use((_socket, next) => {
    next(. None)
    next(. Some(42))
})

which will generate the following JavaScript:

io.use(function (_socket, next) {
      next(undefined);
      return next(42);
    });

Another option could be to use optional arguments, but this doesn't seem to work with uncurrying, and recently there's been bugs with currying that the compiler author seems to have no interest in fixing, so it might not work there either, but it might be worth a shot:

type next = (~error: int=?, unit) => unit
...
io->use((_socket, next) => {
    next(())
    next(~error=42, ())
})

Lastly, there already exists some bindings for socket.io (bs-socket.io). These also don't handle this case unfortunately, but it might save you from re-inventing some wheels at least.

how do Higher Order function understand a variable which is nod fed through function argument?

Your code annotated below:

function greaterThan(n){
  console.log(m); // At this point the below function doesn't exist and has not been called yet
  return m => m > n; // You're returning a function here with a parameter named m;
}

When you call greaterThan(10) you're getting a function, which needs two inputs to return a result:

• m which resolves when you further call the function returned by greaterThan(10)
• n which is is a reference to the greaterThan parameter. It is kept alive (not destroyed by the garbage collector) thanks to the JavaScript's closure mechanism

---

Related Topics