Implementing curry from scratch

Currying transforms f(a, b, c) into a chain where arguments can be supplied in any grouping: f(a)(b)(c), f(a, b)(c), f(a)(b, c). It keeps collecting arguments until it has enough to call the original function.

What the interviewer checks

• Do you use fn.length (the declared arity) to know when to invoke?
• Do you accumulate arguments correctly across multiple calls?

Implementation

Open in editorCopy
function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    }
    return function (...nextArgs) {
      return curried.apply(this, [...args, ...nextArgs]);
    };
  };
}

How it works

fn.length is the number of declared parameters. This is the arity target.

Each call to the curried function either:

• Has enough args (args.length >= fn.length) → invokes fn directly
• Needs more args → returns a new function that merges the accumulated args with the new ones and recurses

Open in editorCopy
const sum = (a, b, c) => a + b + c;
const curriedSum = curry(sum); // fn.length === 3

curriedSum(1)(2)(3);   // 1 call with 1 arg, 2nd with 1, 3rd triggers invoke → 6
curriedSum(1, 2)(3);   // 1 call with 2 args, 2nd triggers invoke → 6
curriedSum(1)(2, 3);   // 1 call with 1 arg, 2nd with 2 triggers invoke → 6

Why fn.length and its limits

fn.length counts declared parameters, excluding rest parameters. A function like f(...args) has length === 0, which breaks this pattern. That's fine — mention it and say currying only makes sense for functions with a fixed arity.

Edge cases to mention

• fn.length === 0 → curried() invokes immediately on the first call with no args
• Extra arguments beyond fn.length are passed through to fn unchanged
• this context is preserved across the chain via .apply(this, ...)