As a developer who spends most of my time at work writing JavaScript or TypeScript, I’ve heard references to ‘currying’ all over the place in blogs, Stack Overflow answers, from my colleagues, and more recently in quiz style technical interviews.
Whenever it gets brought up I do the same thing.
I google the term ‘currying’, figure out that it is basically taking a function that accepts multiple arguments, and converting it into a function that takes one argument, and then returns another function which can take another single argument, etc. etc.
That is to say:
const unCurried = (arg1, arg2, arg3) => {
console.log(`First argument is ${arg1}, second is ${arg2}, third is ${arg3}`);
}
unCurried('this', 'that', 'another');
const curried = (arg1) => {
return (arg2) => {
return (arg3) => {
console.log(`First argument is ${arg1}, second is ${arg2}, third is ${arg3}`);
}
}
}
curried('this')('that')('another');
At which point I say to myself
‘Oh cool yes I remember this. Neat idea. Not sure when I’d use it, but at least I understand it. What a clever JavaScript developer I am’
So maybe, given that currying is a relatively simple concept to implement in code, a better question might be
WTF is the point of currying?
If I stumble onto a concept in mathematics or programming that I don’t understand, I generally try to figure out where it came from, what problem it was/is trying to solve and/or which real world relationship it is trying to model.
So first of all, why is it called ‘currying’? Is there some significance to the name that will make its intention clear?
Currying… maybe it means to preserve something or to add ‘flavor’ to a function in some way?
Nope!!!
Turns out it’s because a logician called Haskell Curry was heavily involved in developing the idea. So that’s a dead end.
It also looks like Haskell Curry was developing his ideas based on the previous ideas of some people called Gottlob Frege (died in 1925), and Moses Schonfinkel (died in 1942). Which suggests that maybe the ideas behind currying did not originally come about in response to a programming problem…
In fact, currying originated as a mathematical technique for transforming maths style functions, rather than programming style functions.
Mathematical functions and programming functions are related, but slightly different.
A mathematical function basically maps one set of data points to another set of data points. That is, for every input value to the function, there is a corresponding, specific output value.
Functions in programming also take inputs, but they can do whatever they like with those inputs (or arguments), and they are under no obligation to return a single specific output value.
Currying, as it is defined, seems to only relate to inputs to functions (arguments), and so is presumably equally applicable to both mathematical and programming style functions. OK cool. What’s currying again?:
‘Currying is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a sequence of functions, each with a single argument.’ – Wikipedia
OK yup I remember, and why do mathematicians curry?
(Based on Wikipedia’s summary)
Some mathematical techniques can only be performed on functions that accept single arguments, but there are lots of examples where relationships that can be modelled as functions need to take multiple inputs.
So currying allows you to to use mathematical techniques that only work on functions with single arguments, but tackle problems that involve multiple inputs.
This is all well and good, and we’ve already seen how we can implement currying in JavaScript, but… I still don’t get what the practical benefit of it is in a programming sense, especially in JavaScript!
Eureka! (A case of accidental currying)
I basically got to the point above, and then went back to ignoring currying as I didn’t really get what practical application it had for me, as a predominantly front end JavaScript developer.
A few months later, I found myself in the privileged position of having a project at work that was entirely my own. I got to write an automated testing solution in Typescript, using Cypress, and was basically given free reign to organise the code and repository as I pleased.
I’ve been gradually moving towards and playing with more functional style programming, and one of the things I found myself wanting to do, was writing functions to create functions with different ‘flavors’:
const pricePrinter = (currencySymbol) => {
return (priceInNumbers) => {
console.log(`${currencySymbol}${priceInNumbers}`);
}
}
const dollarPricePrinter = pricePrinter('$');
const poundPricePrinter = pricePrinter('£');
dollarPricePrinter(15);
poundPricePrinter(15);
Ignoring the wildly impractical nature of the example above, this pattern is quite useful. It allows you to compose functions neatly and semantically, with little ‘function factories’, and talk to code that is sufficiently abstracted.
I was very happy with this pattern and proudly showed my colleague what I’d discovered.
His response was to glance over briefly and go ‘Oh yeah that’s currying. Cool’, and then go back to work.
So there you go. One practical application in JavaScript of currying, is to compose functions together to make little function factories, that are passed the context they will be operating in as an argument (the currency symbol in the example above). Kind of like constructors for functions. Neat.
Disclaimer
I may be wrong. I am happy to be proven wrong. I am equally even happier for someone to give me additional examples of currying in the wild.