How would you implement a curry() function that supports partial application with placeholder arguments?

Q: How would you implement a curry() function that supports partial application with placeholder arguments?

**Target Audience:** Engineers preparing for JavaScript functional-programming interview questions. **Difficulty:** Hard > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every result shown below is **real, captured output** from actually running this doc's curry implementation through 14 real test cases on Node.js v24.19.0 — not illustrative sample output. ## 1. Why This Even Matters — A Story First Filling out a form where some fields you already know the answer to and some you genuinely do not yet, and being allowed to submit what you have while explicitly marking the blanks "fill me in later," is exactly what a placeholder-aware curry gives you. Classic curry only lets you fill the form strictly left to right, one field group at a time — placeholders let you skip around and come back. ## 2. The Core Idea 📌 **Interview term:** currying transforms a function taking `N` arguments into a chain of function

Tricky JavaScript Scenario #84: Function currying with placeholder inputs

The problem

Question presented to candidate: "Implement a curry function that turns any function into one that can be called with its arguments spread across multiple calls — curry(add)(1)(2)(3) should equal add(1, 2, 3). Now extend it to support placeholders, so a caller can skip an argument in an early call and supply it in a later one — curry(add)(_, 2, 3)(1) should also equal add(1, 2, 3). How do you decide, at each call, whether there are finally enough real arguments to actually invoke the original function?"

What a strong answer should cover:

The curried function needs to know the target function's arity (how many arguments it expects) — usually fn.length, though that is wrong for variadic (rest-parameter) functions, so a real implementation should accept an explicit arity override.
At each call, the function is only actually invoked once there are at least arity arguments collected AND none of the first arity slots is still a placeholder — both conditions matter, not just the count.
A placeholder is typically a unique sentinel value (a Symbol, or a well-known exported constant like curry.placeholder, sometimes aliased to _) — never a plain string like "_", since that could collide with a genuine argument value.
When a follow-up call arrives, its new arguments should fill EXISTING placeholders first, left to right, and only append as new trailing arguments once every existing placeholder has been filled.
Multiple placeholders in the same call must each be individually fillable, potentially across multiple separate follow-up calls, not just in one single all-at-once fill.
A correct implementation is a straightforward extension of classic curry: the recursive/closure-returning structure stays the same, only the "are we done yet" check and the "how do we merge args" logic change to account for placeholders.

Clarifying questions expected:

"Should the placeholder be exported as part of the curry function itself, like curry.placeholder, or does the caller supply their own sentinel value?" — affects the public API shape.
"What happens if a follow-up call supplies MORE real values than there are placeholders left to fill?" — a genuine edge case worth resolving explicitly (the extra values are typically appended after the merged, placeholder-filled arguments).

Code / implementation expected: Yes — a full, runnable curry implementation with placeholder support, plus a real, multi-case test suite proving correct behavior for single, multiple, and progressively-filled placeholders.

functional
tricky
real-world

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 functional-programming interview questions. Difficulty: Hard

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every result shown below is real, captured output from actually running this doc's curry implementation through 14 real test cases on Node.js v24.19.0 — not illustrative sample output.

1. Why This Even Matters — A Story First

Filling out a form where some fields you already know the answer to and some you genuinely do not yet, and being allowed to submit what you have while explicitly marking the blanks "fill me in later," is exactly what a placeholder-aware curry gives you. Classic curry only lets you fill the form strictly left to right, one field group at a time — placeholders let you skip around and come back.

2. The Core Idea

📌 **Intervi

The solution is hidden so you can try first

8 min read · 7 sections

Run the code

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

JavaScriptcurry() with placeholder support, plus a real 14-case test suite (run directly)