Intro

Currying is a fundamental concept in functional programming that has gained significant attention in the JavaScript community. It allows developers to create more flexible, modular, and expressive code by transforming functions that take multiple arguments into a series of functions that each take a single argument.

In this blog post, we will dive into the concept of currying in JavaScript and explore how it can enhance your functional programming experience.

What is Currying?

Currying is a technique in functional programming that involves converting a function that accepts multiple arguments into a sequence of functions that each take a single argument.

The main advantage of currying is that it allows developers to create partial applications of a function, which can lead to more reusable and expressive code.

Currying in JavaScript

To illustrate currying in JavaScript, let's consider the following example:

function multiply(a, b) {
  return a * b;
}

const curriedMultiply = (a) => (b) => a * b;1  

console.log(curriedMultiply(2)(3)); // Output: 6

In this example, we define a simple multiply function that takes two arguments, a and b, and returns their product. We then create a curried version of this function, curriedMultiply, which takes a single argument a and returns a new function that takes a single argument b. When the inner function is invoked with b, it calculates the product of a and b.

Partial Application and Currying

One of the primary benefits of currying is the ability to create partial applications of functions. A partial application is a function that has been supplied with some of its arguments but not all, resulting in a new function with a reduced arity (number of expected arguments). This can lead to more reusable and modular code, as demonstrated in the following example:

const curriedMultiply = (a) => (b) => a * b;

const double = curriedMultiply(2);
const triple = curriedMultiply(3);

console.log(double(4)); // Output: 8
console.log(triple(4)); // Output: 12

In this example, we use the curriedMultiply function to create two new functions, double and triple, which represent the partial applications of the curriedMultiply function with a set to 2 and 3, respectively. These new functions can be used independently to double or triple any given number.

Implementing a Currying Utility Function

JavaScript libraries like Lodash and Ramda provide utility functions for currying, but it is also possible to implement your own currying utility function. Here's a simple example:

function curry(fn) {
  const arity = fn.length;

  return function curried(...args) {
    if (args.length >= arity) {
      return fn.apply(this, args);
    } else {
      return (...newArgs) => curried.apply(this, args.concat(newArgs));
    }
  };
}

const multiply = (a, b) => a * b;

const curriedMultiply = curry(multiply);

console.log(curriedMultiply(2)(3)); // Output: 6

In this example, we define a curry function that takes a function fn as its argument and returns a new curried version of the function. The curry function checks if the number of supplied arguments is greater than or equal to the function's arity, and if so, it invokes the original function. Otherwise, it returns a new function that takes the remaining arguments.

Conclusion

Currying is a powerful functional programming technique that promotes modular, reusable, and expressive JavaScript code. By incorporating currying into your projects, you can create partial applications, leading to more efficient and maintainable code.

Thank you for your time

Thank you for taking time and reading this article. I really hope, you have gained some good insights and became even better engineer. Have a great time, do things you love and see you in the next post. 🔥

• Relevant post published by me about Functional Programming