What is Currying in JavaScript?

Currying is a functional programming technique where a function that takes multiple arguments is transformed into a sequence of functions, each taking a single argument. The idea is to "split" a function into multiple smaller functions that each take one argument and return a new function that takes the next argument, until all arguments are provided, and the final result is computed.

In other words, currying allows you to call a function with one argument at a time and progressively build up the final result.

How Currying Works

Consider a function that takes two arguments and returns their sum:

    function add(a, b) {

      return a + b;

    }

With currying, instead of calling add(a, b) with both arguments at once, you create a curried version of the function that takes one argument at a time and returns another function that accepts the next argument.

Example of Currying:

    function curriedAdd(a) {

      return function(b) {

        return a + b;

      };

    }

    const add5 = curriedAdd(5); // Returns a function that adds 5 to its argument

    console.log(add5(3));  // 8

    console.log(add5(10)); // 15

Explanation:

• The curriedAdd function is a function that takes a single argument a and returns another function that takes another argument b.
  
  
• This allows us to call curriedAdd(5) and get a new function (add5), which adds 5 to any argument passed to it.
  
  

A More General Approach to Currying:

A common pattern is to create a higher-order function that can curry any function with multiple arguments:

    function curry(fn) {

      return function curried(...args) {

      if (args.length >= fn.length) {

          return fn(...args); // When the number of arguments is equal to or exceeds the required length, call the original function

       } else {

          return function(...next) {

          return curried(...args, ...next); // Otherwise, return a function that accepts the next argument

      };

    }

  };

}

 // Example usage:

function add(a, b, c) {

  return a + b + c;

}

const curriedAdd = curry(add);

const result = curriedAdd(1)(2)(3);  // 6

console.log(result);

Explanation:

• The curry function takes a function fn as an argument and returns a curried version of it.
  
  
• The curried version checks, if the number of arguments passed (args.length), is enough to satisfy the original function's parameter count (fn.length).
  
  
• If enough arguments are provided, it calls the original function. Otherwise, it returns another function that collects the remaining arguments.
  
  

In this example, add(1)(2)(3) works because the curried add function accumulates arguments until all three are provided and then computes the sum.

Advantages of Currying:

1. Reusability and Partial Application:
   
   
• Currying makes it easier to reuse functions with some pre-set parameters.
  
  
• For example, once you've set a certain parameter (like the number 5 in add5), you can apply it to multiple other values without having to re-specify the same parameter.
  
  
2. More Flexible Function Composition:
   
   
• Currying can be useful when you need to combine several functions together (also known as function composition). You can curry functions to chain or compose them in a cleaner, more modular way.
  
  
3. Partial Application:
• Currying enables partial application: calling a function with fewer arguments than it expects and getting a new function that takes the remaining arguments.
  
  

Example of Partial Application with Currying:

    function multiply(a, b) {

      return a * b;

    }

    // Curried version of multiply

    const curriedMultiply = curry(multiply);

    // Partial application example

    const double = curriedMultiply(2);  // Fixes 'a' to 2

    console.log(double(5));  // 10, effectively multiplying 2 by 5

    const triple = curriedMultiply(3);  // Fixes 'a' to 3

    console.log(triple(5));  // 15, effectively multiplying 3 by 5

 

When to Use Currying:

Currying is especially useful in functional programming and situations where you:

• Need to partially apply a function, i.e., pre-set some arguments for future use.
  
  
• Want to make your functions more modular and reusable by breaking them down into smaller, single-argument functions.
  
  
• They work with functions often passed as arguments to other or higher-order functions.

 

Summary:

• Currying is a technique that transforms a function that takes multiple arguments into a sequence of functions that each take a single argument.
  
  
• It allows for partial application of arguments, where some arguments can be pre-set, and the rest can be provided later.
  
  
• It is useful for creating more modular, reusable, and composable code in functional programming styles.