Question: Reading through the Wikipedia article on First-Class functions, there is a nice table of language support for various aspects of functional programming: <http://en.wikipedia.org/wiki/First-class_function#Language_support>

JavaScript is listed as not having partial function application. However, there are techniques for creating a function that returns a function that with some of the parameters stored in a closure, ie:

```
var add = function(a, b){
    return a + b;
},
apply = function(fn, a){
    return function(b){ 
        return fn(a, b); 
    }
},
addFive = apply(add, 5);

console.log(addFive(2)); // prints 7

```

Is this not partial function application? If not, could someone please provide an example of partial function application in another language and explain how it is different?

Thanks!

Answer: 
What you show is an example of higher order functions, functions that take functions as arguments and/or return functions.

Partial application is something different. [Here a Haskell example](http://www.haskell.org/haskellwiki/Partial_application):

```
add     :: Int -> Int -> Int
add x y = x + y

addOne = add 1

```

`add` is a function that takes two `Int` and returns an `Int`, denoted as `Int -> Int -> Int`. If you're unfamiliar with the syntax, in Javascript this would roughly look like this:

```
/**
 * @param int x
 * @param int y
 * @return int
 */
function add(x, y) {
    return x + y;
}

```

`add 1` calls this function with only one parameter, which returns a new function that takes one `Int` and returns an `Int` (`Int -> Int`). The `add` function was not explicitly designed to be a higher order function, it was simply partially applied.
The concept you should look up to understand this is called currying (after Haskell B. Curry). There is an isomorphism between functions of n+1 parameters and a function with one parameter returning a function with n parameters. If you apply this recursivly you can write a function of any number of parameters as a function to function to functions.

This is why functions in functional languages are usually typed as `X -> Y -> Z` meaning, this is a function which takes a `X` and returns a function taking a `Y` returning a `Z`. This signature also means you can just supply a `X` and the function will return a function itself.

In Javascript a function of two parameters will have the signature `X * Y -> Z` meaning it is a function taking a pair of `X * Y` and returns a `Z`. However you cannot supply half a pair. 

There are two ways out of this:

* Always manually curry your function. Your `add` function could be written as:

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

```

With this you now have a function which has the actual signatur `Int -> Int -> Int` which is needed for partial function application. However you also have to make sure to call this function as `curryadd(5)(10)` which is unnatural to do.

* Supply higher order functions, which curry your functions. In your case the apply does two things, it curries your add function and binds the parameter. This can be divided in two parts:

```
var curry = function(fn) {
    return function(a){ return function(b){ return fn(a,b); } }
};

```

This will actually implement the isomorphism between functions with pairs as arguments and functions which return functions. There also is a way to write `uncurry` which does the same thing backwards. 

Because you have to do all this manually and there is no direct language support, javascript is said not to have partial function application (which does not say you can't add it to the language).