The functional programming application of the currying pattern (Currying)

Currying is a technique that transforms a multi-argument function into a sequence of single-argument functions. It is named after the mathematician Haskell Curry. This pattern is very common in functional programming and can improve code reusability and flexibility. Through currying, we can easily create partially applied functions, defer computations, and compose more complex function logic.

Basic Concepts of Currying

Currying refers to converting a function that takes multiple arguments into a series of nested functions, each accepting a single argument. For example, a function f(a, b, c) that takes three arguments, after currying, becomes f(a)(b)(c). The core idea of this transformation is "step-by-step argument passing," where the final computation is executed only after all arguments have been passed.

// Regular multi-argument function
function add(a, b, c) {
  return a + b + c;
}

// Curried function
function curriedAdd(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
    };
  };
}

console.log(add(1, 2, 3));       // Output: 6
console.log(curriedAdd(1)(2)(3)); // Output: 6

Implementation of Currying

In JavaScript, currying can be implemented manually by writing nested functions or by using a more general utility function to automate the process. Below is a generic currying function implementation:

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));
      };
    }
  };
}

// Example usage
const curriedSum = curry((a, b, c) => a + b + c);
console.log(curriedSum(1)(2)(3)); // Output: 6
console.log(curriedSum(1, 2)(3)); // Output: 6
console.log(curriedSum(1, 2, 3)); // Output: 6

Practical Applications of Currying

Currying has many practical use cases in development, especially when partial function application or function composition is needed. Here are some common examples:

1. Partial Function Application

Currying allows us to fix some arguments in advance, generating a new function, which is useful for handling repetitive logic.

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

const double = curriedMultiply(2);
console.log(double(5)); // Output: 10

const triple = curriedMultiply(3);
console.log(triple(5)); // Output: 15

2. Event Handling

In front-end development, currying can simplify event-handling logic. For example, binding the same event handler to multiple buttons but passing different parameters:

const handleClick = curry((id, event) => {
  console.log(`Button ${id} clicked`, event.target);
});

document.getElementById('btn1').addEventListener('click', handleClick(1));
document.getElementById('btn2').addEventListener('click', handleClick(2));

3. Function Composition

Currying can be combined with other functional programming techniques, such as function composition, to create more complex logic. For example, combining multiple functions into a new function:

const compose = (...fns) => x => fns.reduceRight((acc, fn) => fn(acc), x);

const add5 = x => x + 5;
const multiply3 = x => x * 3;
const square = x => x * x;

const transform = compose(square, multiply3, add5);
console.log(transform(2)); // Output: (2 + 5) * 3 ^ 2 = 441

Pros and Cons of Currying

Pros

1. High Code Reusability: Partial function application reduces repetitive code.
2. Increased Flexibility: New functions can be dynamically generated to adapt to different scenarios.
3. Easier Function Composition: Curried functions are more convenient to compose with other functions.

Cons

1. Performance Overhead: Nested functions increase call stack depth, which may impact performance.
2. Reduced Readability: Code may be harder to understand for developers unfamiliar with currying.

Difference Between Currying and Partial Application

Currying and partial application are often confused, but they are fundamentally different. Currying converts a multi-argument function into a sequence of single-argument functions, while partial application fixes some arguments in advance to generate a new function with fewer arguments.

// Partial application
function partial(fn, ...fixedArgs) {
  return function(...remainingArgs) {
    return fn.apply(this, fixedArgs.concat(remainingArgs));
  };
}

const addPartial = partial(add, 1);
console.log(addPartial(2, 3)); // Output: 6

Advanced Currying Techniques

1. Infinite Argument Currying

The earlier currying implementation requires a fixed number of function arguments (determined by fn.length), but for variadic functions (e.g., sum(...args)), a different implementation is needed:

function infiniteCurry(fn) {
  return function curried(...args) {
    if (args.length === 0) {
      return curried;
    }
    return function(...args2) {
      if (args2.length === 0) {
        return fn(...args);
      }
      return curried(...args, ...args2);
    };
  };
}

const sum = infiniteCurry((...nums) => nums.reduce((acc, num) => acc + num, 0));
console.log(sum(1)(2)(3)()); // Output: 6
console.log(sum(1, 2)(3, 4)()); // Output: 10

2. Uncurrying

Uncurrying converts a curried function back into a regular multi-argument function:

function uncurry(fn) {
  return function(...args) {
    let result = fn;
    for (const arg of args) {
      result = result(arg);
    }
    return result;
  };
}

const uncurriedAdd = uncurry(curriedAdd);
console.log(uncurriedAdd(1, 2, 3)); // Output: 6

Currying in Functional Libraries

Many popular functional programming libraries (e.g., Lodash and Ramda) have built-in currying functionality. For example, in Ramda:

const R = require('ramda');

const ramdaCurriedAdd = R.curry((a, b, c) => a + b + c);
console.log(ramdaCurriedAdd(1)(2)(3)); // Output: 6

// Ramda also supports auto-currying
const autoCurriedAdd = R.curryN(3, (...args) => args.reduce((a, b) => a + b));
console.log(autoCurriedAdd(1, 2, 3)); // Output: 6
console.log(autoCurriedAdd(1)(2)(3)); // Output: 6

Currying with Arrow Functions

ES6 arrow functions make currying implementations more concise:

const arrowCurry = fn => 
  a => b => c => fn(a, b, c);

const arrowAdd = arrowCurry((a, b, c) => a + b + c);
console.log(arrowAdd(1)(2)(3)); // Output: 6

Performance Considerations for Currying

While currying offers many advantages, it should be used cautiously in performance-sensitive scenarios. Each curried call creates a new closure, which may increase memory consumption and call overhead. In most applications, this overhead is negligible, but in high-frequency scenarios (e.g., animations or game loops), optimization may be necessary.

// Non-curried version
function rawAdd(a, b, c) {
  return a + b + c;
}

// Performance test
console.time('raw');
for (let i = 0; i < 1000000; i++) {
  rawAdd(1, 2, 3);
}
console.timeEnd('raw');

console.time('curried');
const cAdd = curry(rawAdd);
for (let i = 0; i < 1000000; i++) {
  cAdd(1)(2)(3);
}
console.timeEnd('curried');