Currying is a functional programming technique that allows you to transform a function with multiple arguments into a sequence of functions that each take a single argument.
function add(a, b, c) {
return a + b + c;
}
function curriedAdd(a) {
return function (b) {
return function (c) {
return a + b + c;
};
};
}
add(1, 2, 3); // 6
curriedAdd(1)(2)(3); // 6You need to understand closures and higher-order functions to understand currying. You can learn more about closures in the following article:
Understanding Closures: Capturing Lexical Environmentsfunction curriedAdd(a) {
return function (b) {
return function (c) {
return a + b + c;
};
};
}
const baseValue = curriedAdd(100);
const baseValueWithGST = baseValue(10);
const baseValueWithGSTAndServiceTax = baseValueWithGST(5);
console.log(baseValueWithGSTAndServiceTax); // 115
We can reuse baseValue, baseValueWithGst and baseValueWithGstAndServiceTax in various parts of our code.
Currying allows for lazy evaluation. This means that a function does not evaluate, until all its arguments are received.
You can create a curried function that can take a variable number of arguments. This is called dynamic currying.
const add = args => args.reduce((a, b) => a + b, 0);
const addItems = (...args) => {
return (...newArgs) => {
if (newArgs.length === 0) return add(args);
return addItems(...args, ...newArgs);
};
};
const base = addItems(100);
const discount = base(-10);
const tips = discount(5);
const tax = tips(8);
tax(); // 103Here, addItems is a higher-order function that returns a curried version of the original function.
// higher order function takes in a variable number of arguments
const addItems = (...args) => {
// returns a function that also takes in a variable number of arguments
return (...newArgs) => {
if (newArgs.length === 0) return add(args);
return addItems(...args, ...newArgs);
};
};The inner function returns the higher-order function again after merging the higher-order function arguments with the inner function arguments.
// for example, base = addItems(100), discount = base(-10)
// args = [100], newArgs = [-10]
return addItems(...args, ...newArgs);Finally when we call addItems without any arguments, we execute the original function, with all the arguments.
// for example, tax()
// args = [100, -10, 5, 8], newArgs = []
if (newArgs.length === 0) return add(args);Fancy word, simple concept. Partial application is when you fix a few arguments of a function and generate a new function that takes the remaining arguments in a curried fashion.
const largePizza = 720;
const sparklingWater = 120;
const salad = 200;
const tax = 160;
// partial application curry
const base = addItems(largePizza, sparklingWater, salad)(tax);
base(); // 1200Currying is a powerful technique that can help you create functions that are more reusable, readable, and flexible. It can also help you write more concise and expressive code.
Currying is a functional programming technique that allows you to transform a function with multiple arguments into a sequence of functions that each take a single argument.
1function add(a, b, c) {
2 return a + b + c;
3}
4
5function curriedAdd(a) {
6 return function (b) {
7 return function (c) {
8 return a + b + c;
9 };
10 };
11}
12
13add(1, 2, 3); // 6
14curriedAdd(1)(2)(3); // 6You need to understand closures and higher-order functions to understand currying. You can learn more about closures in the following article:
Understanding Closures: Capturing Lexical Environments1function add(a, b, c) {
2 return a + b + c;
3}
4
5function curriedAdd(a) {
6 return function (b) {
7 return function (c) {
8 return a + b + c;
9 };
10 };
11}
12
13add(1, 2, 3); // 6
14curriedAdd(1)(2)(3); // 61function curriedAdd(a) {
2 return function (b) {
3 return function (c) {
4 return a + b + c;
5 };
6 };
7}
8
9const baseValue = curriedAdd(100);
10const baseValueWithGST = baseValue(10);
11const baseValueWithGSTAndServiceTax = baseValueWithGST(5);
12
13console.log(baseValueWithGSTAndServiceTax); // 115
14We can reuse baseValue, baseValueWithGst and baseValueWithGstAndServiceTax in various parts of our code.
1function curriedAdd(a) {
2 return function (b) {
3 return function (c) {
4 return a + b + c;
5 };
6 };
7}
8
9const baseValue = curriedAdd(100);
10const baseValueWithGST = baseValue(10);
11const baseValueWithGSTAndServiceTax = baseValueWithGST(5);
12
13console.log(baseValueWithGSTAndServiceTax); // 115
14You can create a curried function that can take a variable number of arguments. This is called dynamic currying.
const add = args => args.reduce((a, b) => a + b, 0);
const addItems = (...args) => {
return (...newArgs) => {
if (newArgs.length === 0) return add(args);
return addItems(...args, ...newArgs);
};
};
const base = addItems(100);
const discount = base(-10);
const tips = discount(5);
const tax = tips(8);
tax(); // 103Here, addItems is a higher-order function that returns a curried version of the original function.
1// higher order function takes in a variable number of arguments
2const addItems = (...args) => {
3 // returns a function that also takes in a variable number of arguments
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};The inner function returns the higher-order function again after merging the higher-order function arguments with the inner function arguments.
1// for example, base = addItems(100), discount = base(-10)
2// args = [100], newArgs = [-10]
3return addItems(...args, ...newArgs);Finally when we call addItems without any arguments, we execute the original function, with all the arguments.
// for example, tax()
// args = [100, -10, 5, 8], newArgs = []
if (newArgs.length === 0) return add(args);1const add = args => args.reduce((a, b) => a + b, 0);
2
3const addItems = (...args) => {
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};
9
10const base = addItems(100);
11const discount = base(-10);
12const tips = discount(5);
13const tax = tips(8);
14tax(); // 1031// higher order function takes in a variable number of arguments
2const addItems = (...args) => {
3 // returns a function that also takes in a variable number of arguments
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};1// for example, base = addItems(100), discount = base(-10)
2// args = [100], newArgs = [-10]
3return addItems(...args, ...newArgs);1// for example, tax()
2// args = [100, -10, 5, 8], newArgs = []
3if (newArgs.length === 0) return add(args);Fancy word, simple concept. Partial application is when you fix a few arguments of a function and generate a new function that takes the remaining arguments in a curried fashion.
1const largePizza = 720;
2const sparklingWater = 120;
3const salad = 200;
4const tax = 160;
5
6// partial application curry
7const base = addItems(largePizza, sparklingWater, salad)(tax);
8base(); // 12001const largePizza = 720;
2const sparklingWater = 120;
3const salad = 200;
4const tax = 160;
5
6// partial application curry
7const base = addItems(largePizza, sparklingWater, salad)(tax);
8base(); // 12001function add(a, b, c) {
2 return a + b + c;
3}
4
5function curriedAdd(a) {
6 return function (b) {
7 return function (c) {
8 return a + b + c;
9 };
10 };
11}
12
13add(1, 2, 3); // 6
14curriedAdd(1)(2)(3); // 61function curriedAdd(a) {
2 return function (b) {
3 return function (c) {
4 return a + b + c;
5 };
6 };
7}
8
9const baseValue = curriedAdd(100);
10const baseValueWithGST = baseValue(10);
11const baseValueWithGSTAndServiceTax = baseValueWithGST(5);
12
13console.log(baseValueWithGSTAndServiceTax); // 115
14You can create a curried function that can take a variable number of arguments. This is called dynamic currying.
const add = args => args.reduce((a, b) => a + b, 0);
const addItems = (...args) => {
return (...newArgs) => {
if (newArgs.length === 0) return add(args);
return addItems(...args, ...newArgs);
};
};
const base = addItems(100);
const discount = base(-10);
const tips = discount(5);
const tax = tips(8);
tax(); // 103Here, addItems is a higher-order function that returns a curried version of the original function.
1// higher order function takes in a variable number of arguments
2const addItems = (...args) => {
3 // returns a function that also takes in a variable number of arguments
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};The inner function returns the higher-order function again after merging the higher-order function arguments with the inner function arguments.
1// for example, base = addItems(100), discount = base(-10)
2// args = [100], newArgs = [-10]
3return addItems(...args, ...newArgs);Finally when we call addItems without any arguments, we execute the original function, with all the arguments.
// for example, tax()
// args = [100, -10, 5, 8], newArgs = []
if (newArgs.length === 0) return add(args);1const add = args => args.reduce((a, b) => a + b, 0);
2
3const addItems = (...args) => {
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};
9
10const base = addItems(100);
11const discount = base(-10);
12const tips = discount(5);
13const tax = tips(8);
14tax(); // 1031// higher order function takes in a variable number of arguments
2const addItems = (...args) => {
3 // returns a function that also takes in a variable number of arguments
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};1// for example, base = addItems(100), discount = base(-10)
2// args = [100], newArgs = [-10]
3return addItems(...args, ...newArgs);1// for example, tax()
2// args = [100, -10, 5, 8], newArgs = []
3if (newArgs.length === 0) return add(args);1const largePizza = 720;
2const sparklingWater = 120;
3const salad = 200;
4const tax = 160;
5
6// partial application curry
7const base = addItems(largePizza, sparklingWater, salad)(tax);
8base(); // 12001const add = args => args.reduce((a, b) => a + b, 0);
2
3const addItems = (...args) => {
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};
9
10const base = addItems(100);
11const discount = base(-10);
12const tips = discount(5);
13const tax = tips(8);
14tax(); // 1031// for example, tax()
2// args = [100, -10, 5, 8], newArgs = []
3if (newArgs.length === 0) return add(args);1const add = args => args.reduce((a, b) => a + b, 0);
2
3const addItems = (...args) => {
4 return (...newArgs) => {
5 if (newArgs.length === 0) return add(args);
6 return addItems(...args, ...newArgs);
7 };
8};
9
10const base = addItems(100);
11const discount = base(-10);
12const tips = discount(5);
13const tax = tips(8);
14tax(); // 1031// for example, tax()
2// args = [100, -10, 5, 8], newArgs = []
3if (newArgs.length === 0) return add(args);