Partial application and currying are two popular concepts from functional programming and help cut code replication in certain scenarios. This article assumes an understanding of the JavaScript bind function; binding is related to partial application in JavaScript.

**Partial Application**

In pure functional languages, functions are not ‘*invoked’*, rather a set of arguments is ‘*applied’* to them. Now, if all the arguments are not passed in, then the function is being ‘*partially*‘ applied.

Partial application converts variadic functions (i.e. functions with multiple parameters) into functions of lesser arity by pre-specifying certain argument values.

Lets take the exponential function (x^y) from the mathematics domain as an example; an exponent value of 2 gives the square function while a value of 3 gives the cube function. The base exponential function has one of its inputs fixed to a certain value.

Let us take a simple example with sums to see how partial application can lead to new functions.

```
function add(a,b) {
return a + b;
}
//partial application
function incrementBy(n) {
return add.bind(null,n);
}
var add2 = incrementBy(2);
add2(2);
//4
var add4 = incrementBy(4);
add4(10);
//14
```

**Currying**

No, not Indian/Pakistani Curry (they taste awesome by the way… :) ). The name Curry comes from Haskell Curry, a renowned mathematician who has a lot of things named after him (Haskell is another one) .

Currying is somewhat similar – it turns a variadic function into a sequence of chained monadic (i.e. single argument) functions. For example, a curried triadic function will be invoked as a chain of 3 monadic functions.

```
function add(a,b) {
return a + b;
}
//currying
function curriedAdd(a) {
return function(b) {
return add(a,b);
};
}
curriedAdd(3)(4);
//7
var add3 = curriedAdd(3);
add3(7);
//10
```

That was a simple example, let’s look at a more generic curry function.

```
function curry (fn)
{
var arity = fn.length,
exec = function (args) {
args = args || [];
return function helper(){
var helperArgs =
[].slice.apply(arguments);
var argsTally =
args.concat(helperArgs);
if(argsTally.length &gt;= arity){
return fn.apply(null,argsTally);
}else{
return exec(argsTally);
}
};
};
return exec();
}
function sum (x,y,z) {
return x * y * z;
};
curriedProduct = curry(sum);
curriedProduct(1)(2)(3);
curriedProduct(1, 2)(3);
curriedProduct(1, 2, 3);
curriedProduct(1)(2, 3);
//All return 6
```

**How does this work?!**

Let’s dive in and take it apart! Fun!!

1. The length property of the function being curried is its arity (number of expected parameters).

2. The * exec* function allows currying until all parameters are matched, its

**array grows during repeated invocations.**

*args*3. The * helper* function is returned on curry calls. Its

*array allows capturing new parameters until the original function’s arguments are all matched.*

**helperArgs**If the number of parameters in * helperArgs *equals the original function’s arity, then all parameters have been passed in and we can execute the function successfully. Otherwise, returning the

**function with the updated arguments allows currying to continue.**

*exec*This process continues batching up arguments until the curried function’s arity is matched or exceeded.

4. Note that extra parameters are dropped when functions are called with excessive arguments. The curry tastes good with extra input ;)

### Tracing the execution of currying

A curried function’s execution is traced out below:

*curriedProduct =* curry(sum);

[arity:3]

-> exec() -> helper() //Gets returned to curriedProduct

```
curriedProduct(1,2)(3)
<i>-> helper(1,2)</i>
[argsTally: [1,2], argsTally.length(2) < arity(3)]
-> exec([1,2])
-> helper()
[args:[1,2]; available to helper through closure]
-> helper(3)
[argsTally:[1,2,3]; argsTally.length(3) >= arity(3)]
-> sum.apply(null, [1,2,3])
-> 6
```

**Note: **Technically, currying allows only monadic functions…

**Differences** between partial application and currying

While it does seem currying and partial application are the same thing but for two subtle differences:

1. Currying will only invoke the original function when all parameters have been passed in while partial application will invoke the base function regardless of this.

2. Curried functions will always return new functions until all arguments have been applied whereas partially applied functions will always return the same base function with some pre-determined argument values. This becomes quite obvious in functions with an arity > 2.

**Why should I care about currying or partially-applied functions?**

1. Allows you to think in a new way about programming.

2. Both concepts allow you to create new helper functions and utilities that are useful in a lot of situations.

3. Functional programming is cool.

4. At least you now (hopefully) know the difference between partial application and currying!

**Conclusion**

What do you think about both functional programming concepts? Add your comments and do check out other interesting posts.

1. Understanding Tail Recursion

2. Programming Language Type Systems II

Reblogged this on 49514262200010.

LikeLike