JS interview in 2 minutes / Currying 🥘

#javascript #typescript #beginners #career

Question:
What is currying in JavaScript?

Quick answer:
It is a technique used to convert a function that takes multiple arguments into a chain of functions where every only takes one argument.

Longer answer:
Currying is basically all about Higher Order Functions. It is an application of JavaScript's ability to return functions from other functions.

We are replacing a function that takes n arguments with a set of n functions, which applied one by one gives exactly the same answer as original functions.

We can learn it by example right away. Btw it feels like this one is the most common one.

// regular implementation
function add1(a, b) {
  return a + b;
}

console.log(add1(2,5)) // 7

// curried implementation
function add2(a) {
  return function(b) {
    return a + b
  }
}

console.log(add2(2)(5)) // 7

That is it. This is what currying is.

UPD: btw, also check out @kspeakman note about currying vs non-currying partial application in the comments section

Real-life applications:
At first glance, it may look a bit weird 🤯 Why do we ever need to call a function separating arguments?

You can think of it as a function preparation for execution. If you have some common operation, e.g. getting an object property, you can move it to a curried version.

function searchUser {
  // ...
  user['id']
  // ...
}

function updateUser {
  // ...
  user['id']
  // ...
}

// user['id'] can be refactored with
let getUserId = user => user['id']

// Or you can go even further and implement generic getter
let pluck = name => object => object[name]
let getUserId = pluck('id')
let getUserName = pluck('name')

let name = getUserName(user)

So functions like this can be joined to some helpers library. And here is RxJS.pluck and here is Ramda.pluck.

Have a good curry 🥘

Resources:
wiki/Currying

Other posts:

Btw, I will post more fun stuff here and on Twitter. Let's be friends 👋

Top comments (5)

Kasey Speakman • May 14 '21

Currying is mainly a way to setup a function for easier partial application -- providing only some of the function arguments. You can do partial application without currying, but it is less convenient.

// currying partial application
let add = a => b => a + b
let add2 = add(2)
add2(7)
// 9

// non-currying partial application
let add = (a, b) => a + b
let add2 = b => add(2, b)
add2(7)
// 9