# Grokking Partial Application

If you started programming in an imperative language such as Java like I did, learning to grok functional programming can be a daunting endeavor.

What partial application, or known by some as "currying" after the late mathematician Haskell Curry, is applying a function to a value, which returns another function yet to be applied to another value.

Look at the following function in JavaScript:

``````const add = (a) => (b) => x + y
``````

As you first apply this function to the first number 9, it replaces `a` and returns the function `(b) => 9 + b`:

``````const addNine = add(9)
// -> (9) => (b) => 9 + n2
// -> (b) => 9 + n2
``````

We end up with a half-applied function `addNine` that, when applied to another number, will add it to number 9 which is being stored on the stack. In another word, the computation was being suspended until the next application.

This is indeed different from the following function:

``````const add = (a, b) => a + b
``````

If we partially applied this function to a single value 5,`a` would be substituted with a number while `b` will be undefined, resulting in an execution of `5 + undefined` which equals to `NaN`, a very obscure result to ever be returned by a language.

Functions in functional languages such as Ocaml and Haskell are curried, which means they apply to each value at a time no matter how many parameters they have. Take these two Haskell functions, which are similar:

``````add1 :: Int -> Int -> Int
add1 a b = a + b

add2 :: Int -> Int -> Int
add2 a = \b -> a + b
``````

The line above each function's definition is the function's type declaration. They show that both functions are in fact the same—a two-step application process to the end value.