What is currying?

Q: What is currying?

**Target Audience:** Engineers preparing for JavaScript fundamentals/functional-programming interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . The generic curry helper and its three calling patterns below were actually run in Node. ## 1. Why This Even Matters — A Story First Ordering a custom sandwich usually happens all at once: "wheat bread, turkey, no mustard" in a single sentence. Currying is more like a sandwich-order kiosk that asks one question at a time — "bread?" then, once answered, "meat?" then "condiments?" — and only actually makes the sandwich once every question has been answered, however many separate visits to the kiosk that takes. Both approaches specify the exact same sandwich; currying just lets the specification happen incrementally, and lets you stop partway to reuse a partial order later. ## 2. The Core Idea 📌 **Interview term:** currying transforms

The problem

Question presented to candidate: "What is currying, and can you show me how you'd write a generic curry() helper that works for any function, regardless of how many arguments it takes?"

What a strong answer should cover:

📌 Interview term: currying — transforming a function that takes multiple arguments into a sequence of functions, each taking a single argument (or a subset), where calling with fewer than all the needed arguments returns a new function waiting for the rest.
📌 Interview term: the real, direct answer to the prompt — verified directly: a generic curry(fn) helper genuinely worked correctly across three different calling patterns for the same 3-argument function — all-at-once (curriedAdd3(1, 2, 3)), one-then-two (curriedAdd3(1)(2, 3)), and fully split (curriedAdd3(1)(2)(3)) — all producing the identical, correct real result.
📌 Interview term: partial application — currying's most common real, practical payoff: calling a curried function with FEWER than all its arguments produces a new, reusable, "pre-configured" function — verified directly with a real tax-calculation example, where partially applying just the tax rate produced a genuinely reusable function correctly applied to multiple different prices.
A precise answer names fn.length as the real mechanism most generic curry implementations use to know how many arguments to wait for before actually invoking the original function — a precise, verified detail beyond just describing the general idea.
A precise answer distinguishes currying from simple partial application via bind: bind pre-fills a fixed number of leading arguments once; a curried function genuinely supports being called with any split of arguments across any number of calls, not just one fixed split.

Clarifying questions expected:

None — this is a definitional/technical question; producing a real, working generic curry implementation (not just a hard-coded 2-argument example) is the strong signal.

Code / implementation expected: Yes — a real, generic curry() helper verified to work across multiple calling patterns for the same function is the clearest, most convincing demonstration.

currying

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals/functional-programming interviews. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. The generic curry helper and its three calling patterns below were actually run in Node.

1. Why This Even Matters — A Story First

Ordering a custom sandwich usually happens all at once: "wheat bread, turkey, no mustard" in a single sentence. Currying is more like a sandwich-order kiosk that asks one question at a time — "bread?" then, once answered, "meat?" then "condiments?" — and only actually makes the sandwich once every question has been answered, however many separate visits to the kiosk that takes. Both approaches specify the exact same sandwich; currying just lets the specification happen incrementally, and lets you stop partway to reuse

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptA real, generic curry() helper verified across multiple argument-splitting patterns, plus a real partial-application example