Lesson 16 of 80

Currying

Q: What is currying, how is it implemented under the hood, and how does it differ from plain partial application?

A strong answer covers: Currying transforms a multi-argument function into a chain of single-argument functions, e.g. f(a,b,c) becomes f(a)(b)(c); Implemented purely with closures — each returned function closes over the arguments already collected; Partial application pre-fills some arguments and returns a function for the rest in one step, without requiring strictly one argument per step.

Turning a function that takes several arguments into a chain of functions that each take one — built entirely out of closures returning closures.

12 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

Question 1 of 2

In `function add(a) { return b => a + b; }`, what mechanism lets the returned function still access `a` after `add` has already returned?

Closures — the returned function closes over add's scope, including aJavaScript automatically caches the last call's arguments globallya is hoisted out of add into the module scope

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Currying

What interviewers actually ask about this, and what a strong answer has to cover.

What is currying, how is it implemented under the hood, and how does it differ from plain partial application?

A strong answer covers

Currying transforms a multi-argument function into a chain of single-argument functions, e.g. f(a,b,c) becomes f(a)(b)(c)
Implemented purely with closures — each returned function closes over the arguments already collected
Partial application pre-fills some arguments and returns a function for the rest in one step, without requiring strictly one argument per step

Likely follow-ups

Write a generic curry(fn) that works for any function regardless of how many arguments it takes.
Give a real use case where a curried/partially-applied function is more useful than the plain version.
Does currying cost anything at runtime — extra closures, extra calls? When would that matter?

Practice these with the AI interviewer →

The plain-language idea

Currying transforms f(a, b, c) into f(a)(b)(c) — a chain of one-argument functions, where each one remembers the arguments already given and waits for the next.

function add(a) {
  return function (b) {
    return function (c) {
      return a + b + c;      // closes over a, b, and c
    };
  };
}

add(1)(2)(3); // 6

const addFive = add(5);      // partially applied — a is locked in at 5
addFive(2)(3);                // 10

Each returned function is a closure over the arguments collected so far. That's the whole mechanism — currying isn't a special language feature, it's an ordinary pattern of functions returning functions, each one remembering what came before.

Currying: closures, one argument at a timeStep 1 of 4

add(1)(2)(3) — a chain of calls, not one call with three arguments.

What people usually miss

Watch out

It's closures all the way down — if you understand closures, curried functions aren't a new concept, just a specific shape built from the same mechanism as debounce or a counter factory.
Curried functions compose well. addFive above is a reusable, specialized function — currying is how you turn one general function into a family of specific ones without rewriting anything.
Real-world use: partially-applied config. const fetchWithBase = (base) => (path) => fetch(base + path) — fetchWithBase("/api") gives you a ready-to-reuse function that already knows its base URL.

Why this matters in interviews

"Write a curry function that works for any function's arity" is a common exercise that tests closures, recursion, and Function.prototype.length all at once — it's a good proxy for whether closures actually clicked, not just whether you can define the term.