# 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.