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.

## Top comments (0)