JavaScript Currying & Partial Application Interview Questions

What currying looks like

// Regular function — takes all arguments at once
function add(a, b) {
  return a + b
}
add(2, 3)  // 5

// Curried version — takes one argument at a time
function curriedAdd(a) {
  return function(b) {
    return a + b
  }
}

curriedAdd(2)(3)     // 5
const add2 = curriedAdd(2)  // partially applied — 'a' is locked in as 2
add2(3)              // 5
add2(10)             // 12
add2(100)            // 102

With arrow functions, curried functions become extremely compact:

const add = a => b => a + b
const multiply = a => b => a * b
const greet = greeting => name => `${greeting}, ${name}!`

add(5)(3)                 // 8
const add5 = add(5)
add5(3)                   // 8
add5(10)                  // 15

greet('Hello')('Alice')   // 'Hello, Alice!'
const sayHello = greet('Hello')
sayHello('Alice')         // 'Hello, Alice!'
sayHello('Bob')           // 'Hello, Bob!'

Partial application — the practical payoff

Partial application means calling a curried function with only some of its arguments, getting back a specialized function. This is where currying earns its place in real codebases.

// A generic validator function
const validate = (min) => (max) => (value) => value >= min && value <= max

const isValidAge   = validate(0)(120)    // specialized: 0-120
const isValidScore = validate(0)(100)    // specialized: 0-100
const isAdult      = validate(18)(120)   // specialized: 18+

isValidAge(25)    // true
isValidAge(150)   // false
isValidScore(85)  // true
isAdult(16)       // false

// A curried API call helper
const fetchFrom = (baseUrl) => (endpoint) => (id) =>
  fetch(`${baseUrl}${endpoint}/${id}`).then(r => r.json())

const fetchFromAPI    = fetchFrom('https://api.example.com')
const fetchUsers      = fetchFromAPI('/users')
const fetchProducts   = fetchFromAPI('/products')

fetchUsers(123)     // GET https://api.example.com/users/123
fetchProducts(456)  // GET https://api.example.com/products/456

Building a curry() utility function

A general-purpose curry() function automatically converts any multi-argument function into a curried one:

function curry(fn) {
  return function curried(...args) {
    // If we've collected enough arguments, call the original function
    if (args.length >= fn.length) {
      return fn.apply(this, args)
    }
    // Otherwise, return a function that collects more arguments
    return function(...moreArgs) {
      return curried.apply(this, args.concat(moreArgs))
    }
  }
}

// Using curry()
function add(a, b, c) {
  return a + b + c
}

const curriedAdd = curry(add)

curriedAdd(1)(2)(3)   // 6 — one at a time
curriedAdd(1, 2)(3)   // 6 — two then one
curriedAdd(1)(2, 3)   // 6 — one then two
curriedAdd(1, 2, 3)   // 6 — all at once (still works)

Currying vs partial application — the distinction

These terms are often used interchangeably but are technically different:

// Currying: a function that ALWAYS takes ONE argument and returns
// a function until all arguments are collected
const curriedAdd = a => b => c => a + b + c
curriedAdd(1)       // function waiting for b
curriedAdd(1)(2)    // function waiting for c
curriedAdd(1)(2)(3) // 6

// Partial application: fixing SOME (not necessarily one) arguments
// ahead of time and getting back a function for the rest
function partialAdd(a, b) {
  return function(c) {
    return a + b + c
  }
}
const add1and2 = partialAdd(1, 2)  // fixed 2 args at once
add1and2(3)  // 6

// JavaScript's .bind() is built-in partial application
function add(a, b, c) { return a + b + c }
const add5 = add.bind(null, 5)   // pre-fills a=5
add5(2, 3)   // 10 — b=2, c=3

Currying with array methods — functional composition

// Curried helper functions compose naturally with map/filter/reduce
const multiply  = a => b => a * b
const isOver    = n => x => x > n
const hasProperty = key => obj => key in obj

const numbers = [1, 2, 3, 4, 5]
const users = [
  { name: 'Alice', age: 25, active: true },
  { name: 'Bob',   age: 17, active: false },
  { name: 'Carol', age: 32, active: true },
]

// These read like plain English:
numbers.map(multiply(3))             // [3, 6, 9, 12, 15]
numbers.filter(isOver(3))            // [4, 5]
users.filter(hasProperty('active'))  // all three
users.map(u => u.name)               // ['Alice', 'Bob', 'Carol']

// Combining multiple curried transforms:
const getActiveSeniorNames = users =>
  users
    .filter(isOver(18)(_.get('age')))  // illustrative — use real impl
    .filter(hasProperty('active'))
    .map(u => u.name)

Currying in function composition (pipe / compose)

// Function composition uses currying to build data pipelines
const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x)

const process = pipe(
  x => x * 2,
  x => x + 1,
  x => x.toString(),
  x => `Result: ${x}`
)

process(5)   // 'Result: 11'
// 5 → 10 → 11 → '11' → 'Result: 11'

// Real-world: processing API response
const processUser = pipe(
  user => ({ ...user, name: user.name.trim() }),
  user => ({ ...user, email: user.email.toLowerCase() }),
  user => ({ ...user, createdAt: new Date(user.createdAt) }),
)

Arity — why it matters for currying

Arity is the number of parameters a function expects. fn.length returns it. Currying relies on knowing the arity to know when enough arguments have been collected:

const add = (a, b, c) => a + b + c
add.length  // 3

// Rest parameters break arity detection:
const sum = (...args) => args.reduce((a, b) => a + b, 0)
sum.length  // 0 — rest parameters don't count

// Default parameters also:
const greet = (name, greeting = 'Hello') => `${greeting}, ${name}`
greet.length  // 1 — only counts parameters before the first default