## Higher-order functions in Javascript

In Javascript, functions are just like the other variables(AKA first-class citizen), and here are several interesting tricks implemented by treating functions as first-class citizen.

## currying

Currying is for partial evaluation, a practical example is Function.prototype.bind() in Javascript:

```var add = function(a, b) {
return a + b;
};

```

And we can implement `bind()`(under this circumstance only of course) by ourselves:

```var bind = function(f, n) {
return function() {
return f.apply(null, [n].concat([...arguments]));
};
};

var add = function(a, b) {
return a + b;
};

```

## trampolining

Javascript(ES5) does not implement tail call optimization, so using recursion incorrectly(such as calculating Factorial) will lead to a stack-overflow exception. However, this can be avoided by returning a higher-order function, which is called trampolining.

First, we can easily get written `factorial()` done:

```function factorial(n){
return n == 1 ? n : n * factorial(n-1);
}
```

But this is not a tail-call recursion, let’s update this method by adding another parameter:

```function tail_factorial(n, result) {
return n == 1 ? result : tail_factorial(n - 1, n * result);
}
```

Now, we get a tail-call recursion function which ES5 can not optimize, and we are still facing the stack-overflow problem. So let’s look at our trampoline function:

```function trampoline(fn){
return function(){
var result = fn.apply(this, arguments);
while(result instanceof Function){
result = result();
}
return result;
}
}

function tail_factorial(n, result) {
return n == 1 ? result : function() {
return tail_factorial(n - 1, n * result)
};
}

trampoline(tail_factorial)(7, 1)  // 5040
```

However, using trampoline here is just showing concepts of higher-order function and not recommended, for in programming languages like PHP and Javascript it may cause a great performance loss.