Currying & partial application

Change a function’s shape

JavaScript functions are flexible values. You can store them in variables, pass them to map, return them from other functions, and attach methods like bind. Currying and partial application use that flexibility to change when a function receives its arguments.

The job stays ordinary. Add tax. Format money. Sort products. Build a URL. The shape changes so repeated details can be filled in once and reused later.

This lesson assumes you know closures, because saved arguments live in closures, and call, apply & bind, because bind can save leading arguments. We will also touch functions are objects and object-to-primitive conversion for the chainable sum trick.

Imagine a function as a form with blanks. A normal call fills every blank at once: priceWithTax(0.08, 50). Partial application fills one or more blanks now and gives you a new form with fewer blanks: const addEightPercent = addTax(0.08).

The lab shows three versions. A closure saves rate. bind saves the first argument of multiply and fixes this at the same time. A generic partial helper stores any preset list and forwards the later list.

1const addTax = (rate) => (price) => {Run2  return Number((price * (1 + rate)).toFixed(2));3};4 5const addEightPercent = addTax(0.08);6console.log(addEightPercent.length);7console.log(addEightPercent(50));

Notice the arity detail. bind reduces length by the number of preset arguments. A rest-parameter helper like (...later) => ... has length 0, even when the human meaning is “one suffix remains.” Arity is a clue, not a contract.

Currying is stricter in shape. A curried function returns a function, which may return a function, until enough arguments have been collected. The original function runs at the last stage, not at the first stage.

1function curry(fn) {Run2  return function curried(...args) {3    if (args.length >= fn.length) {4      return fn(...args);5    }6    return (...more) => curried(...args, ...more);7  };8}9 10const add3 = (a, b, c) => a + b + c;11const curriedAdd3 = curry(add3);12console.log(curriedAdd3(1)(2)(3));

This common helper uses fn.length. If the collected argument count is high enough, it calls the original function. Otherwise it returns another function that remembers the current arguments. That is why curry(add3)(1)(2)(3) and curry(add3)(1, 2)(3) can both end at 6.

In JavaScript, a function’s length counts parameters before the first default value. It does not count rest parameters. That means a small curry helper can call too early when a function has defaults, or miss the meaning of a rest parameter entirely.

1function curry(fn) {2  return function curried(...args) {3    return args.length >= fn.length4      ? fn(...args)5      : (...more) => curried(...args, ...more);6  };7}8 9const withDefault = (a, b = 10, c) => a + b + c;10const withRest = (label, ...values) => label + values.join("-");11console.log(withDefault.length);12console.log(typeof curry(withDefault)(1));13console.log(withRest.length);14console.log(curry(withRest)("id"));

Professional libraries solve this by asking for an explicit arity, designing data-last helpers carefully, or avoiding automatic currying for functions with defaults and rest parameters. You can still write curried functions by hand when the public shape matters: const between = (min) => (max) => (value) => value >= min && value <= max.

Chainable sums are a fun way to prove functions can return functions forever. They are not the same as ordinary currying, because there is no fixed final arity. The chain needs a separate signal that says “stop and show the number.”

1function sum(total) {2  function next(value) {3    return sum(total + value);4  }5  next[Symbol.toPrimitive] = () => total;6  return next;7}8 9console.log(`${sum(1)(2)}`);10console.log(sum(1)(2) + 0);11console.log(sum(1)(2)(3) + 0);

The Symbol.toPrimitive version is surprising: `${sum(1)(2)}` and sum(1)(2) + 0 ask the function to become a primitive. A plain console.log(sum(1)(2)) may show a function representation instead; consoles display objects and functions in their own way. The empty-call version is less magical: the final () is the terminator.

Point-free style removes parameter names when they do not add information. The everyday rewrite is items.map((item) => format(item)) becoming items.map(format). It reads nicely when the function accepts exactly what the caller passes.

1const items = ["  tea", "cake  "];2const format = (item) => item.trim().toUpperCase();3 4console.log(items.map((item) => format(item)).join(", "));5console.log(items.map(format).join(", "));6console.log(["1", "2", "3"].map(parseInt).join(", "));7 8const addTax = (rate) => (price) => price * (1 + rate);9const formatMoney = (value) => "$" + value.toFixed(2);10const withSalesTax = (price) => formatMoney(addTax(0.08)(price));11console.log([10, 20].map(withSalesTax).join(", "));

The classic trap is ["1", "2", "3"].map(parseInt). map passes (value, index, array). parseInt reads its second argument as the radix. So the index accidentally changes the base. The safe version is explicit: (value) => parseInt(value, 10).

1const items = ["  tea", "cake  "];2const format = (item) => item.trim().toUpperCase();3 4console.log(items.map((item) => format(item)).join(", "));5console.log(items.map(format).join(", "));6console.log(["1", "2", "3"].map(parseInt).join(", "));7 8const addTax = (rate) => (price) => price * (1 + rate);9const formatMoney = (value) => "$" + value.toFixed(2);10const withSalesTax = (price) => formatMoney(addTax(0.08)(price));11console.log([10, 20].map(withSalesTax).join(", "));

These patterns shine when one option repeats across many calls: currency, locale, tax rate, validation rule, logging prefix, API base path, or sort direction. They are less helpful when the wrapper is used once and hides the real arguments.

1const byPrice = (direction) => (a, b) =>2  direction === "asc" ? a.price - b.price : b.price - a.price;3 4const products = [5  { name: "Pencil", price: 1 },6  { name: "Notebook", price: 4 },7  { name: "Backpack", price: 30 },8];9 10console.log(products.toSorted(byPrice("desc")).map((item) => item.name).join(", "));

Common misconceptions

• “Partial application and currying are the same.” They overlap, but partial application is about saving some arguments; currying is about staged function shape.
• “Point-free is always cleaner.” It is cleaner only when the callback’s arguments line up with the function’s parameters.
• “fn.length tells me all required arguments.” It stops at defaults and ignores rest parameters.
• “bind only changes this.” It can also preset leading arguments, which is partial application.
• “Curried functions are free.” Each stage usually allocates a closure. That is fine most of the time, but it is still real work.
• “Chainable sums are production style.” They are mostly a lesson in closures and coercion. Use clear APIs for teams.

Key takeaways

• Partial application presets some arguments and returns a smaller function.
• Currying collects arguments across staged calls and runs the original function later.
• fn.length is useful but breaks down with defaults and rest parameters.
• Chainable sums are great for learning closures and coercion, not a default API style.
• Point-free style works only when callback arguments match the function’s parameters.

Up next: Composition & pipelines.