How do you implement infinite currying in JavaScript?

Q: How do you implement infinite currying in JavaScript?

**Target Audience:** Engineers preparing for JavaScript closures and functional-programming interview questions. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every result below was actually run on Node.js v24.19.0 — captured output, not illustrative sample text. ## 1. Why This Even Matters — A Story First Think of a vending machine that keeps a running tab open: each coin you insert (each function call) adds to the tab and hands you back the exact same machine, ready for another coin. The machine never tells you the total on its own -- only when you press the "show total" button (coercing it to a primitive) does it read out the accumulated number. Infinite currying works the same way: every call returns something still callable, quietly building up a total behind the scenes, and the total only becomes visible the moment something forces it to. ## 2. The Core Idea 📌 **Interview

The problem

Question presented to candidate: "Write a function add such that add(1)(2)(3) eventually evaluates to 6 -- and the number of calls is not fixed, so add(1)(2)(3)(4)(5) should evaluate to 15. How would you implement that, and how does the runtime actually know when to stop chaining and produce a number?"

What a strong answer should cover:

Currying in general means turning a function that takes multiple arguments into a chain of functions that each take one argument (or a group), returning a new function until enough arguments have arrived.
Infinite currying cannot rely on counting a fixed number of calls, because there is no fixed arity -- instead, each call returns another callable function that also carries an overridden valueOf/toString, so the chain can be extended indefinitely.
The chain never "auto-terminates" by itself -- JavaScript only calls valueOf/toString when something coerces the returned function to a primitive, such as the + operator, a template literal, or JSON.stringify. Until that coercion happens, add(1)(2)(3) is still just a function sitting there.
An alternative, more explicit style avoids relying on implicit coercion entirely: return a callable object with a distinct terminator method, such as .call() or .done(), that the caller invokes explicitly to end the chain -- more verbose, but avoids the somewhat surprising, coercion-only quirk that a plain console.log(add(1)(2)(3)) prints a function, not a number.
Each intermediate function must close over the running total via a closure, so the accumulated sum persists across calls.

Clarifying questions expected:

"Should the terminator be implicit, through coercion like plus or a template literal, or should I add an explicit terminator method the caller has to call?"
"Does this need to support passing multiple arguments per call, like add(1, 2)(3), or strictly one argument per call?"

Code / implementation expected: Yes -- a real, executed implementation using the valueOf/toString coercion trick, plus a contrasting explicit-terminator version, both actually run and confirmed to produce correct sums for chains of varying length and grouping.

currying
closures
functional

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 closures and functional-programming interview questions. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every result below was actually run on Node.js v24.19.0 — captured output, not illustrative sample text.

1. Why This Even Matters — A Story First

Think of a vending machine that keeps a running tab open: each coin you insert (each function call) adds to the tab and hands you back the exact same machine, ready for another coin. The machine never tells you the total on its own -- only when you press the "show total" button (coercing it to a primitive) does it read out the accumulated number. Infinite currying works the same way: every call returns something still callable, quietly building up a total behind the scenes, and the total only b

The solution is hidden so you can try first

8 min read · 8 sections

Run the code

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

JavaScriptInfinite currying via valueOf/toString coercion, plus an explicit-terminator alternative (run directly)