JavaScript Currying

JavaScript currying is a technique used to transform a function that takes multiple arguments into a sequence of functions that each take a single argument. The resulting functions can be called individually, or the entire sequence can be called as a single function, with each argument supplied one at a time.

To put it simply, currying is like breaking down a complex function into smaller, simpler functions that can be composed together.

Here's an example of a function that takes two arguments and returns their sum:

function add(a, b) {
  return a + b;
}        

To curry this function, we can use a higher-order function that returns a new function that expects one argument at a time:

function add(a) {
  return function(b) {
    return a + b;
  };
}        

This function can now be used like this:

const add2 = add(2); // returns a function that expects one argument
const result = add2(3); // returns 5        

Here, we first create a new function add2 by passing the first argument "2" to the "add" function. This returns a new function that expects the second argument. We then call add2 with the second argument "3", which returns the result "5".

Currying can also be achieved using ES6 arrow functions:

const add = a => b => a + b;
const add2 = add(2);
const result = add2(3); // returns 5        

Here, we use arrow functions to create the curried function add. The function add takes one argument "a" and returns another arrow function that takes one argument "b" and returns the sum of "a" and "b". We can then use this function in the same way as the previous example.

Currying can be a powerful technique when used appropriately. It can help to simplify complex functions, increase code re-usability, and enable easier function composition.