Currying & Partial Application

Currying and partial application are two related techniques from functional programming that transform functions to make them more reusable and composable. Both rely on closures to remember previously supplied arguments.

Currying

Currying transforms a function that takes multiple arguments into a sequence of functions that each take a single argument. A curried version of f(a, b, c) becomes f(a)(b)(c) — each call returns a new function that expects the next argument, until all arguments are supplied and the result is computed.

Basic implementation:

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) return fn(...args);
    return (...moreArgs) => curried(...args, ...moreArgs);
  };
}

This generic curry wrapper checks fn.length (the number of declared parameters). If enough arguments are provided, it calls the original function. Otherwise, it returns a new function that accumulates more arguments via closure.

Partial Application

Partial application fixes one or more arguments of a function upfront and returns a new function that accepts the remaining arguments. Unlike currying, it doesn't require unary functions — you can fix any number of arguments at once.

JavaScript has built-in partial application via Function.prototype.bind(): const double = multiply.bind(null, 2) fixes the first argument to 2. You can also implement it manually with closures: const partial = (fn, ...fixed) => (...rest) => fn(...fixed, ...rest).

Key Difference

Currying always produces a chain of unary (single-argument) functions — f(a)(b)(c). Partial application fixes a specific set of arguments and returns one function that takes the rest — f(a, b) with first arg fixed becomes g(b). Currying is a specific form of transformation; partial application is a more general concept. A curried function can be partially applied by calling it with fewer arguments than it needs.

Real-World Use Cases

Configuration functions: Create a base function with shared settings, then specialize it. const apiCall = curry((baseUrl, endpoint, params) => fetch(baseUrl + endpoint, params)). Then const myApi = apiCall('https://api.example.com') creates a pre-configured function.

Event handlers: const handleClick = curry((action, elementId, event) => { ... }). Pre-fill the action and element, pass the resulting function directly to addEventListener.

Validation: const isInRange = curry((min, max, value) => value >= min && value <= max). Create const isValidAge = isInRange(0, 120) — a reusable validator.

Function composition: Curried functions compose naturally. const pipeline = compose(format, validate, parse) — each function in the pipeline takes one argument and returns one result.

Closures as the Foundation

Both patterns fundamentally depend on closures. When a curried function receives its first argument, that argument is captured in the closure of the returned function. Each subsequent call creates a new closure that captures the next argument while retaining access to all previous arguments.

Key Interview Distinction

Currying transforms a multi-argument function into a chain of single-argument functions. Partial application fixes some arguments and returns a function for the rest. bind() provides built-in partial application in JavaScript. Both patterns enable function reuse and composition, and both rely on closures to remember fixed arguments.