What Is Currying in JavaScript?
Understand JavaScript currying — turning multi-argument functions into chained single-argument calls via closures — with code examples.
Expected Interview Answer
Currying is the technique of transforming a function that takes multiple arguments into a sequence of functions that each take a single argument, returning a new function at each step until all arguments have been supplied and the original computation finally runs.
A normal function `add(a, b, c)` takes all three arguments at once, but its curried form `curriedAdd(a)(b)(c)` takes them one at a time, with each call returning a new function that closes over the arguments received so far. This relies entirely on closures: each intermediate function remembers the previously supplied arguments in its scope, so by the time the final argument arrives, everything needed to compute the result is already captured. Currying enables partial application — fixing some arguments early to produce specialized, reusable functions, such as building `add5 = curriedAdd(5)` once and calling `add5(10)` many times with different second arguments. It is a functional-programming pattern most useful for composing pipelines, configuring reusable utilities (like a curried `fetch` wrapper preset with a base URL), and making point-free code more declarative, though it can hurt readability and debuggability if overused for functions that never benefit from partial application.
- Enables partial application to create specialized, reusable functions
- Relies on closures to accumulate arguments across calls cleanly
- Improves composability in functional pipelines
- Makes configuration-then-execution patterns explicit and reusable
AI Mentor Explanation
A curried delivery is like a bowler setting up a plan in stages: first choosing the line, then separately choosing the length, then finally choosing the pace, with the ball only released once all three decisions are locked in. Each stage remembers the earlier choices — picking “outswing line” first lets the bowler reuse that same line decision across many deliveries while varying only length and pace afterward. That is exactly how curried functions work: each call fixes one argument and returns a new function remembering it, until the final argument triggers execution. Currying just formalizes this build-up-then-execute pattern for regular JavaScript functions.
Step-by-Step Explanation
Step 1
Identify the multi-argument function
Start with a function like `add(a, b, c)` that normally takes all arguments at once.
Step 2
Return a chain of single-argument functions
Rewrite it so each call takes one argument and returns a new function.
Step 3
Close over accumulated arguments
Each returned function captures previously supplied arguments via closure.
Step 4
Execute on the final argument
Once the last expected argument arrives, the original computation runs and returns the result.
What Interviewer Expects
- Clear definition distinguishing currying from generic partial application
- Understanding of closures as the mechanism that makes currying work
- Ability to write a curry() helper or manually curried function
- Awareness of real use cases (config-then-execute, composition) vs overuse
Common Mistakes
- Confusing currying (strict one-argument-at-a-time) with generic partial application
- Not explaining that closures are what retain earlier arguments
- Overusing currying for functions that gain no reuse benefit, hurting readability
- Writing a curry helper that fails for functions with variable arity
Best Answer (HR Friendly)
“Currying means breaking a function that takes several inputs into a chain of functions that each take one input at a time. So instead of calling `add(1, 2, 3)`, you call `add(1)(2)(3)`. It is useful because you can lock in some values early and reuse that partially filled-in function later with different remaining values.”
Code Example
// Manually curried
const add = (a) => (b) => (c) => a + b + c
console.log(add(1)(2)(3)) // 6
const add5 = add(5) // partial application
console.log(add5(10)(1)) // 16
// Generic curry helper for any fixed-arity function
function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args)
}
return (...more) => curried.apply(this, [...args, ...more])
}
}
const curriedAdd = curry((a, b, c) => a + b + c)
console.log(curriedAdd(1, 2)(3)) // 6
console.log(curriedAdd(1)(2, 3)) // 6Follow-up Questions
- How does currying differ from generic partial application?
- How would you write a `curry` helper that works for any function arity?
- What is a practical use case for currying in a real codebase?
- How do closures make currying possible under the hood?
MCQ Practice
1. What does currying transform a multi-argument function into?
Currying restructures a function so each call supplies one argument and returns the next function in the chain.
2. What JavaScript mechanism allows a curried function to remember earlier arguments?
Each returned function closes over previously supplied arguments in its enclosing scope.
3. What is a key practical benefit of currying?
Fixing some arguments early produces a reusable specialized function, which is the main practical payoff.
Flash Cards
What is currying? — Transforming a multi-argument function into a chain of single-argument functions.
What mechanism makes currying work? — Closures, which retain previously supplied arguments across calls.
What does currying enable? — Partial application — fixing some arguments early to build reusable specialized functions.
add(1)(2)(3) vs add(1,2,3)? — The first is curried (one argument per call); the second is the normal uncurried form.