In JavaScript, what is the difference between currying a function and partially applying it?

## The distinction in one line Currying changes the *shape* of a function. Partial application changes *how much of it you have supplied so far*. A curried function is one whose call signature is a chain of single-argument calls; a partially applied function is the leftover of a normal function after some arguments were already fixed. ## Currying: one argument per call A function of arity three, curried by hand, is three nested single-parameter functions: ```js const add3 = (a, b, c) => a + b + c; const curriedAdd3 = (a) => (b) => (c) => a + b + c; add3(1, 2, 3); // 6 curriedAdd3(1)(2)(3); // 6 curriedAdd3(1); // a function, not a number ``` Each intermediate call returns a new function; nothing is computed until the last argument arrives. `curriedAdd3.length` is `1`, because each step declares exactly one parameter, and each intermediate value is a fresh function object — calling `curriedAdd3(1)` twice gives you two distinct functions that behave the same. ## Partial application: pin some, keep the rest Partial application starts from an ordinary multi-argument function and produces a function of smaller arity: ```js function greet(greeting, name) { return `${greeting}, ${name}!`; } const hi = greet.bind(null, 'Hi'); hi('Ada'); // "Hi, Ada!" hi.length; // 1 — one parameter still outstanding ``` `Function.prototype.bind` is the language's built-in partial application: everything after its first argument is stored and prepended to whatever you pass later. A closure does the same job without `bind`: ```js const partial = (fn, ...fixed) => (...rest) => fn(...fixed, ...rest); const hi2 = partial(greet, 'Hi'); ``` Notice there is no chain here. `hi` is not "the curried greet"; it is `greet` with one slot already filled. ## Where the two meet Calling a curried function with one argument *is* a partial application of it — that is why the terms blur. The clean way to keep them apart: currying is a property of the function's definition, partial application is something you do to a function at a call site. You can partially apply a function that was never curried (`bind`), and you can curry a function without ever partially applying it (call the whole chain in one expression). Most real-world `curry` helpers are "loose" or auto-curried: they accept any number of arguments per call and only invoke the underlying function once enough have accumulated. ```js const curried = curry(add3); curried(1)(2)(3); // 6 curried(1, 2)(3); // 6 curried(1, 2, 3); // 6 ``` Strictly, `curried(1, 2)` is currying plus partial application at once. Say so explicitly in an interview — it shows you know the difference rather than merely reciting it. ## Why anyone bothers Both exist so that configuration can be separated from data. A logging helper written argument-order "config first, data last" can be specialised once and reused: ```js const log = (level) => (msg) => console.log(`[${level}] ${msg}`); const warn = log('WARN'); warn('disk almost full'); ``` That data-last ordering is what makes curried helpers usable in pipelines without writing a wrapper arrow at every step. With arguments ordered data-first, currying gains you very little, because the piece you want to fix is the one you would have to supply first. ## Traps worth naming A curried or partially applied function is still an ordinary function that ignores no arguments: hand `curried` to a callback API that passes extra arguments and the loose helper may consider itself complete far earlier than you intended. Partial application via `bind` can only pin arguments **from the left** — there is no built-in placeholder for "skip the second parameter". And neither operation mutates or replaces the original function; both return a new function object, so the original stays callable in its normal form.