Understanding and Implementing JavaScript’s Currying

By /
Photo by Mohammad Rahmani on Unsplash

Currying is a powerful functional programming technique that transforms a function with multiple arguments into a series of functions, each taking a single argument. This approach not only enhances code readability and reusability but also enables the creation of more flexible and modular functions. In this article, we’ll delve into the concept of currying, explore its benefits, and provide detailed examples of how to implement currying in JavaScript.

What is Currying?

Currying is a process in which a function, instead of taking all its arguments at once, takes them one by one, returning a new function for each argument. This process continues until all arguments have been provided, at which point the final result is computed.

Example:

A simple example to illustrate currying is a function that adds two numbers:

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

// Curried version
function curriedAdd(a) {
  return function(b) {
    return a + b;
  };
}
let addFive = curriedAdd(5);
console.log(addFive(3)); // Output: 8
console.log(curriedAdd(5)(3)); // Output: 8

Explanation:

In the non-curried version, add takes two arguments at once. In the curried version, curriedAdd takes the first argument a and returns a new function that takes the second argument b. This returned function then performs the addition.

Benefits of Currying

  1. Modularity: Currying breaks down functions into smaller, more manageable parts.
  2. Reusability: Curried functions can be reused with partial application of arguments.
  3. Readability: Currying can make the code more readable and expressive.

Implementing Currying in JavaScript

Let’s explore different ways to implement currying in JavaScript.

Manual Currying

We can manually curry a function by returning nested functions.

function multiply(a) {
  return function(b) {
    return function(c) {
      return a * b * c;
    };
  };
}
let result = multiply(2)(3)(4);
console.log(result); // Output: 24

Explanation:

In this example, multiply is manually curried to take one argument at a time. The result is computed only after all three arguments are provided.

Using Higher-Order Functions

We can create a higher-order function to automate currying for any given function.

function curry(func) {
  return function curried(...args) {
    if (args.length >= func.length) {
      return func.apply(this, args);
    } else {
      return function(...nextArgs) {
        return curried.apply(this, args.concat(nextArgs));
      };
    }
  };
}

function addThreeNumbers(a, b, c) {
  return a + b + c;
}
let curriedAddThreeNumbers = curry(addThreeNumbers);
console.log(curriedAddThreeNumbers(1)(2)(3)); // Output: 6
console.log(curriedAddThreeNumbers(1, 2)(3)); // Output: 6
console.log(curriedAddThreeNumbers(1)(2, 3)); // Output: 6

The curry function takes another function func as an argument and returns a new function curried. The curried function checks if the number of arguments provided is sufficient to call func. If not, it returns a new function that collects additional arguments until all required arguments are provided.

Practical Applications of Currying

Example 1: Partial Application

Currying allows for partial application, where some arguments are fixed, and a new function is returned for the remaining arguments.

function greet(greeting) {
  return function(name) {
    return `${greeting}, ${name}!`;
  };
}
let sayHello = greet('Hello');
console.log(sayHello('Alice')); // Output: Hello, Alice!
console.log(greet('Hi')('Bob')); // Output: Hi, Bob!

In this example, greet is curried to take the greeting argument first and return a new function that takes the name argument. This allows us to create specialized greeting functions like sayHello.

Example 2: Function Composition

Currying can be used to create more modular and composable functions.

function compose(f, g) {
  return function(x) {
    return f(g(x));
  };
}
function addTwo(x) {
  return x + 2;
}
function multiplyByThree(x) {
  return x * 3;
}
let addTwoThenMultiplyByThree = compose(multiplyByThree, addTwo);
console.log(addTwoThenMultiplyByThree(4)); // Output: 18

In this example, compose takes two functions f and g and returns a new function that applies g to its argument and then f to the result. This creates a new function addTwoThenMultiplyByThree that first adds two to its argument and then multiplies the result by three.

Currying is a fundamental concept in functional programming that can significantly improve the modularity, reusability, and readability of your JavaScript code. By transforming functions to take arguments one at a time, currying enables partial application, function composition, and other powerful programming techniques. Understanding and implementing currying in JavaScript will enhance your ability to write clean, maintainable, and flexible code. Embrace currying in your programming practice to unlock its full potential and elevate your JavaScript skills.

Understanding and Implementing JavaScript’s Currying was originally published in CarlosRojasDev on Medium, where people are continuing the conversation by highlighting and responding to this story.

Scroll to Top