Currying in Functional Programming – A Beginners Guide

Learn currying in JavaScript and Python with practical examples, understand currying vs partial application, and discover when this functional programming pattern is useful.

Updated August 2026 — full tutorial restored for this URL.

TL;DR

• Currying transforms a multi-argument function into a chain of functions that each accept one argument.

• In JavaScript, currying can turn add(a, b) into add(a)(b) and create reusable functions such as add5.

• Python supports similar patterns using nested functions and tools such as functools.partial.

• Currying and partial application differ: currying supplies arguments one at a time, while partial application fixes some arguments for later use.

• Use currying for reusable handlers, predicates, and configurable functions, but prioritize readability in everyday code.

Currying turns a function that takes multiple arguments into a chain of functions that each take one argument. It is a core idea in functional programming and shows up in JavaScript libraries and Python tooling.

Related: Monads for Beginners.

1. What currying means
2. JavaScript examples
3. Python examples
4. Currying vs partial application
5. When to use it

1. What currying means

A normal function: add(a, b). A curried form: add(a)(b). After you supply a, you get a new function waiting for b.

2. JavaScript examples

const add = (a) => (b) => a + b;
const add5 = add(5);
console.log(add5(3)); // 8

// generic curry (arity 2+)
const curry = (fn) => {
  const nest = (...args) =>
    args.length >= fn.length
      ? fn(...args)
      : (...more) => nest(...args, ...more);
  return nest;
};

const volume = curry((l, w, h) => l * w * h);
console.log(volume(2)(3)(4)); // 24

3. Python examples

from functools import partial

def add(a, b):
    return a + b

add5 = partial(add, 5)
print(add5(3))  # 8

def curry2(fn):
    def outer(a):
        def inner(b):
            return fn(a, b)
        return inner
    return outer

cadd = curry2(add)
print(cadd(5)(3))

4. Currying vs partial application

• Currying always produces unary steps (one arg at a time) until the original arity is filled.
• Partial application fixes some arguments now and accepts the rest later (any count).

5. When to use it

• Configurable handlers: const log = (level) => (msg) => …
• Reusing predicates in filters/maps
• Avoid over-currying APIs your teammates must call daily — readability wins

Final Thoughts

Currying is a simple but powerful functional programming technique that can make functions more reusable and composable. By supplying arguments one at a time, you can create specialized functions from more general ones and reuse them across your application.

JavaScript makes currying especially natural with arrow functions, while Python offers related techniques through nested functions and functools.partial. Understanding the distinction between currying and partial application is important because the two approaches solve similar problems in different ways.

As with any programming pattern, the goal is not to use currying everywhere. Use it where it makes function composition and reuse clearer, and choose straightforward function calls when they make the code easier for your team to understand.