What is Currying? Use Cases in JavaScript

Currying is a common technique in functional programming. It involves converting a multi-parameter function into a sequence of single-parameter (or fewer-parameter) functions. The primary purpose is to enable parameter reuse, partial application, and deferred execution.

Definition

For example, in JavaScript, a basic implementation of currying can be:

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

This curry function takes a function fn as a parameter and returns a new function curried. The new function checks the number of arguments provided; if sufficient to execute the original function, it executes it immediately; otherwise, it returns a new function that awaits additional arguments.

Use Cases

1. Parameter Reuse:
   For functions that need to be called multiple times with certain parameters unchanged, currying allows you to create specialized functions by passing only the varying parameters. For instance, given an add function, you can create addFive that adds 5 to a number.

   javascript
   function add(a, b) {
     return a + b;
   }
   const addFive = curry(add)(5);
   addFive(10); // Returns 15

2. Deferred Computation/Execution:
   Currying enables you to distribute the acquisition of multiple parameters across several steps. The function executes only when all required parameters are provided, which is beneficial when waiting for data before performing operations. For example, if a function requires data from multiple sources, you can pass each result sequentially into the curried function.

3. Dynamic Function Generation:
   Currying enables dynamic generation of functions. When handling event listeners or callbacks, if certain parameters are known, you can create a new function without redefining the function body.

   javascript
   const on = curry(function(eventType, element, callback) {
     element.addEventListener(eventType, callback);
   });
   const onClick = on('click');
   onClick(document.getElementById('myButton'), () => console.log('Button clicked!'));

4. Function Composition:
   In functional programming, currying facilitates function composition. It allows you to seamlessly pass the output of one function as input to another, which is particularly useful for creating data streams and middleware in chained operations.

   javascript
   const compose = (f, g) => (a) => f(g(a));
   const multiplyBy2 = (n) => n * 2;
   const addTen = (n) => n + 10;
   const multiplyBy2AndAddTen = compose(addTen, multiplyBy2);
   multiplyBy2AndAddTen(5); // Returns 20

In summary, currying is a powerful technique in functional programming that enables the creation of more flexible and reusable code in JavaScript. It facilitates advanced programming patterns such as parameter reuse, deferred execution, and higher-order function construction.