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)