What Is ‘currying’?

Currying is a concept in functional programming that allows you to transform a function with multiple arguments into a sequence of functions, each taking a single argument. This technique is named after the mathematician Haskell Curry.

Currying can be useful in JavaScript when you want to create reusable functions or when you need to partially apply arguments to a function. It allows you to create new functions by fixing some of the arguments of an existing function.

Let’s take a look at an example to understand how currying works:

function add(x) {
  return function(y) {
    return x + y;
  };
}

const addFive = add(5);
console.log(addFive(3)); // Output: 8

In the above code snippet, we have a function add that takes a single argument x and returns another function that takes a single argument y. The inner function adds x and y and returns the result.

By calling add(5), we fix the value of x to 5 and get a new function addFive. When we call addFive(3), it adds 5 and 3, resulting in 8.

This technique allows us to create specialized functions from more general functions. We can create functions that add a specific value to the given argument, making our code more modular and reusable.

Another way to achieve currying in JavaScript is by using the bind() method. The bind() method creates a new function with a specified this value and initial arguments provided.

function multiply(x, y) {
  return x * y;
}

const multiplyByTwo = multiply.bind(null, 2);
console.log(multiplyByTwo(5)); // Output: 10

In the above example, we use the bind() method to create a new function multiplyByTwo from the multiply function. We pass null as the first argument to bind() since we don’t need to set the this value. We fix the value of x to 2, and when we call multiplyByTwo(5), it multiplies 2 and 5, resulting in 10.

Currying is a powerful technique that can enhance the flexibility and reusability of your code. It allows you to create specialized functions by fixing some of the arguments of an existing function. Whether you choose to use nested functions or the bind() method, currying can be a valuable tool in your JavaScript toolkit.