JavaScript Notes

JavaScript Currying - Complete Guide with Examples

Learn JavaScript currying with step-by-step examples, closures, partial application, real-world use cases, common mistakes, and top interview Q&A.

What is Currying?

Currying is a functional programming technique where a function that takes multiple arguments is transformed into a sequence of functions, each taking one argument at a time.

One-liner: Currying turns f(a, b, c) into f(a)(b)(c).

A curried function doesn't run until all its arguments are provided. Each intermediate call returns a new function waiting for the next argument — powered by closures.

Why Use Currying?

Reusability — create specialized functions from general ones
Composability — chain functions in a pipeline
Partial application — pre-fill some arguments, supply rest later
Readability — describe transformations as a chain

Basic Currying Example

Without Currying

js example

function add(a, b) {
  return a + b;
}

console.log(add(3, 5));

Output

With Currying

js example

function add(a) {
  return function(b) {
    return a + b;
  };
}

const addThree = add(3);  // Returns a function with a=3 remembered
console.log(addThree(5)); // Supplies b=5
console.log(add(3)(5));   // Direct chain call

Output

8
8

Step-by-Step Execution Trace

Example

Step 1: add(3) is called → a = 3 is stored in closure → returns inner function (waiting for b) Step 2: addThree(5) is called → b = 5 is the argument → closure retrieves a = 3 → computes 3 + 5 = 8 → returns 8

Closure Visualization

Example

┌──────────────────────────────────────────────────────┐ │ add(3) creates closure │ │ │ │ ┌────────────────────────────────────────────────┐ │ │ │ OUTER: add(a) │ │ │ │ a = 3 ← stored in closure │ │ │ │ │ │ │ │ ┌──────────────────────────────────────────┐ │ │ │ │ │ INNER: function(b) │ │ │ │ │ │ b = 5 (provided on next call) │ │ │ │ │ │ a = 3 (from closure — remembered!) │ │ │ │ │ │ returns: a + b = 8 │ │ │ │ │ └──────────────────────────────────────────┘ │ │ │ └────────────────────────────────────────────────┘ │ └──────────────────────────────────────────────────────┘

Arrow Function Currying

Arrow functions make curried functions extremely concise:

Example

const multiply = (a) => (b) => a * b; const double = multiply(2); const triple = multiply(3); console.log(double(5)); console.log(triple(5)); console.log(multiply(4)(6));

Output

10
15
24

Three-Level Currying

Example

Output

Hello, Mr. Sharma!
Hello, Mr. Verma!
Hi, Ms. Patel!

Real World Use Case 1 — Configurable Logger

Example

Output

[ERROR] [Auth] Invalid token
[ERROR] [Auth] Session expired
[WARN] [Database] Connection slow

Real World Use Case 2 — Discount Calculator

Example

const applyDiscount = (discountRate) => (price) => price - price * (discountRate / 100); const tenPercentOff = applyDiscount(10); const twentyPercentOff = applyDiscount(20); console.log(tenPercentOff(500)); console.log(tenPercentOff(200)); console.log(twentyPercentOff(1000));

Output

450
180
800

Real World Use Case 3 — URL Builder

Example

Output

https://api.wohotech.com/api/v2/users
https://api.wohotech.com/api/v2/posts
https://api.wohotech.com/api/v2/comments

Generic curry() Implementation

js example

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      // All arguments supplied — call the original function
      return fn(...args);
    }
    // Return a function collecting more args
    return function(...moreArgs) {
      return curried(...args, ...moreArgs);
    };
  };
}

// Usage
function add(a, b, c) {
  return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3));
console.log(curriedAdd(1, 2)(3));
console.log(curriedAdd(1)(2, 3));
console.log(curriedAdd(1, 2, 3));

Output

How the generic curry() works:

Example

curriedAdd(1): args = [1], fn.length = 3 1 < 3 → return function waiting for more args curriedAdd(1)(2): args = [1, 2], fn.length = 3 2 < 3 → return function waiting for more args curriedAdd(1)(2)(3): args = [1, 2, 3], fn.length = 3 3 >= 3 → call add(1, 2, 3) → returns 6

Infinite Currying (Add Forever)

js example

function infiniteAdd(a) {
  return function(b) {
    if (b === undefined) return a;
    return infiniteAdd(a + b);
  };
}

console.log(infiniteAdd(1)(2)(3)());
console.log(infiniteAdd(5)(10)(15)());

Output

6
30

Call with no argument to get the accumulated result.

Currying vs Partial Application

These are related but different concepts:

Feature	Currying	Partial Application
Splits into	One argument at a time	Any number of arguments
Implementation	Nested functions	`bind()` or custom
Fixed structure	Yes — `f(a)(b)(c)`	Flexible
Example	`add(1)(2)`	`add.bind(null, 1)(2)`

js example

// Partial application with bind
function add(a, b) { return a + b; }
const add5 = add.bind(null, 5); // Pre-fill a=5
console.log(add5(3)); // b=3 → 8

Output

Common Mistakes

❌ Mistake 1 — Calling Curried Function All At Once

Example

const multiply = (a) => (b) => a * b; // WRONG — only supplies 'a', doesn't supply 'b' console.log(multiply(3));

Output

[Function (anonymous)]

js example

// CORRECT
console.log(multiply(3)(4));

Output

❌ Mistake 2 — Expecting Infinite Curry to Resolve Automatically

Example

function add(a) { return b => a + b; } const result = add(1)(2); // This is fine — but: add(1)(2)(3) would break because // result is already a number (3), not a function

❌ Mistake 3 — Confusing Currying with Closure

Currying uses closures, but they aren't the same thing:

Closure: A function that remembers its outer scope
Currying: A technique of breaking multi-arg functions into chains of single-arg functions

All curried functions use closures, but not all closures are currying.

Currying in Practice — Redux Middleware

Example

// Redux middleware follows the currying pattern: const logger = (store) => (next) => (action) => { console.log("Dispatching:", action.type); const result = next(action); console.log("New state:", store.getState()); return result; };

This three-level curried function is the signature of every Redux middleware.

Interview Questions 🎯

Q1. What is currying in JavaScript?

Currying is a technique where a function with multiple parameters is transformed into a sequence of functions, each accepting one argument at a time. f(a, b, c) becomes f(a)(b)(c). The intermediate functions hold the already-received arguments via closures.

Q2. How does currying use closures?

When the first argument is passed, the outer function stores it in its local scope and returns an inner function. The inner function has access to the outer scope via closure, so it can reference the first argument when the next argument arrives. This chain continues for each argument.

Q3. What is the difference between currying and partial application?

Currying: Always one argument per call — strict f(a)(b)(c) structure
Partial application: Pre-fill any number of arguments at once — more flexible

Currying is a specific form of partial application.

Q4. Write a curried function to add three numbers.

Example

const add = (a) => (b) => (c) => a + b + c; console.log(add(1)(2)(3));

Output

Q5. Write a generic curry() function.

Example

function curry(fn) { return function curried(...args) { return args.length >= fn.length ? fn(...args) : (...more) => curried(...args, ...more); }; }

Q6. What is infinite currying?

A currying pattern where calling with no argument returns the accumulated result, while calling with an argument continues adding:

js example

function add(a) {
  return function(b) {
    if (b === undefined) return a;
    return add(a + b);
  };
}
console.log(add(1)(2)(3)()); // 6

Q7. Where is currying used in real JavaScript?

Redux middleware: (store) => (next) => (action) => {}
Lodash/Ramda: _.curry(fn)
React HOCs: connect(mapState)(Component)
Event handlers with configuration: handler(config)(event)
URL builders, loggers, validators with configurable parameters

Q8. Does currying affect performance?

Currying adds overhead because each call creates a new function object (closure). For performance-critical hot paths, regular function calls are faster. But for code organization, reusability, and composition, the overhead is negligible.

Key Takeaways 🔑

Currying transforms f(a, b, c) → f(a)(b)(c) using closures
Each intermediate call returns a new function waiting for the next argument
The original function only runs when all arguments are supplied
Enables partial application — specialize functions by pre-filling arguments
Arrow functions make currying very concise: (a) => (b) => a + b
A generic curry() utility uses fn.length to know when all args are ready
Widely used in Redux, React HOCs, functional libraries (Lodash, Ramda)

Practice Problems

Write a curried function multiply(a)(b)(c) that multiplies three numbers.
Create a curried filter(predicate)(array) function.
Implement the generic curry(fn) utility from scratch.
Write a curried URL builder for buildUrl(protocol)(domain)(path).
Implement infinite currying sum(1)(2)(3)(4)() that adds until called with no args.

Summary

Currying is a functional programming technique that transforms a multi-argument function into a chain of single-argument functions. Each call returns a new function (via closure) that waits for the next argument — the original function only executes once all arguments are collected. Currying enables code reuse (create specialized functions from general ones), function composition, and partial application. In JavaScript, it's implemented naturally through closures, is extremely concise with arrow functions, and is widely used in Redux middleware, React patterns, and functional libraries like Lodash and Ramda.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for JavaScript Currying - Complete Guide with Examples.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this JavaScript Master Course topic.

Search Terms

javascript-complete-guide, javascript master course, javascript, complete, guide, advanced, currying, javascript currying - complete guide with examples

Continue learning this concept

Advanced JavascriptJavaScript apply() Method - Complete Guide with ExamplesMaster JavaScript apply() method with syntax, this binding, array arguments, function borrowing, real-world use cases, common mistakes, and interview Q&A.Advanced JavascriptJavaScript bind() Method - Complete Guide with ExamplesMaster JavaScript bind() with permanent this binding, partial application, event handlers, currying patterns, common mistakes, and top interview Q&A.Advanced JavascriptJavaScript call() Method - Complete Guide with ExamplesMaster JavaScript call() method: this binding, syntax, constructor inheritance, function borrowing, strict mode differences, and top interview Q&A.Advanced JavascriptJavaScript call() vs apply() vs bind() - Complete Comparison GuideMaster JavaScript call vs apply vs bind with side-by-side comparisons, decision rules, real examples, this binding diagrams, and top interview Q&A.Advanced JavascriptJavaScript Debounce - Complete Guide with Timeline DiagramsMaster JavaScript debounce with implementation, timeline diagrams, search input examples, debounce vs throttle comparison, and top interview Q&A.Advanced JavascriptJavaScript Execution Context - Complete Guide with Stack DiagramsMaster JavaScript Execution Context: global, function, eval contexts, call stack, creation vs execution phases, this binding, hoisting, and interview Q&A.

PreviousJavaScript call() vs apply() vs bind() - Complete Comparison Guide NextJavaScript Debounce - Complete Guide with Timeline Diagrams