Currying and partial application in JavaScript

Anton Ioffe - September 7th 2023 - 15 minutes read

Mastering JavaScript can be a complex yet rewarding endeavor, especially when you unlock the efficient, robust techniques it offers, such as currying and partial application. These techniques, which harness the power of higher-order functions and closures, pave the way for greater control, maintainability, readability, and reusability of your code. In this in-depth article, we will explain these topics in a detailed and digestible manner, opening doors to exciting new avenues in your JavaScript programming adventures.

The article commences with higher-order functions and closures, ensuring that we establish a strong foundation of JavaScript function behaviors before we venture into the nuances of currying and partial application. We will then unravel the secrets of currying in JavaScript, enabling you to comprehend how the decomposition of a function into a sequence of functions can optimise your code structure.

Onward, we will shine a light on the concept of partial application, exploring its purpose, benefits, and unique behaviors, complemented with practical examples. We will also highlight the distinctions between currying and partial application, assisting you in choosing the suitable technique for your programming challenges. To wrap up, we will dive into complex JavaScript concepts as we link these techniques to function composition, closures, and potential JavaScript interview scenarios. This comprehensive overview provides a perfect platform for you to understand, practice, and implement currying and partial application in JavaScript effectively.

JavaScript Functions: Higher-order Functions and Closures Explained

Before venturing into complex concepts like currying and partial application, let's take a comprehensive look at some fundamental aspects of JavaScript functions. Specifically, we'll delve into higher-order functions and closures. Understanding these concepts is essential, as they form the foundational blocks that pave the way towards a deeper understanding of more advanced applications of JavaScript, like currying and partial functions. Furthermore, imagine how closures and higher-order functions work together? Keep this question in mind as we embark on this exploration.

What are Higher-Order Functions?

In JavaScript, functions are first-class citizens, meaning functions are treated like any other variable: they can be stored in arrays, utilized as object properties, and passed as arguments.

A higher-order function is a function that either accepts one or more functions as arguments, or returns a function as its result. Beyond storing functions, the ability to return a function showcases the dynamic nature of JavaScript, permitting functions to be created on the fly during execution.

Before providing an example, let's clarify the concept of a "callback" function: a function passed into another function as an argument, then invoked within that outer function. In essence, a callback function is a technique for ensuring certain code does not execute until other code has completed its execution.

Now, here's a high-order function using a callback:

function greetAndIntroduce(name, callback) {
    console.log(`Hello, ${name}!`);

function introduce(){
    console.log('Nice to meet you!');

greetAndIntroduce('John Doe', introduce);

As you can see, greetAndIntroduce() qualifies as a higher-order function because introduce(), a function itself, serves as an argument.

Common Mistake:

A common pitfall when using callback functions lies in calling the function when passing it, instead of simply passing the function reference. Consider the following:

greetAndIntroduce('John Doe', introduce()); // WRONG 

The above code will prompt an error because we're invoking the function instead of passing its reference. The correction is straightforward:

greetAndIntroduce('John Doe', introduce); // RIGHT

Pass the function by reference, not by invoking it.

Understanding Closures

Closures, vital to mastering JavaScript, are simply functions bundled with their lexical environments. Lexical environments hold variable declarations. Consequently, closures grant an inner function access to the outer (enclosing) function's variables, a.k.a. its scope chain. This chain comprises:

  1. The closure's own scope - variables defined between its curly brackets.
  2. The outer function's variables.
  3. Global variables.

For better understanding, consider this closure example:

function outerFunction(outerVariable) {
    return function innerFunction(innerVariable){
        console.log('outerVariable:', outerVariable);
        console.log('innerVariable:', innerVariable);

const newFunction = outerFunction('outside'); 
newFunction('inside'); // Logs: "outerVariable: outside" and "innerVariable: inside"

Here, innerFunction, being a closure, encompasses its own scope (innerVariable), the scope of outerFunction(outerVariable), and the global scope.

Common Mistake:

While closures seem manageable, a prevalent mistake regarding closures involves misunderstanding their scope. Specifically, some developers overlook that a closure retains access to the outer function's variables, even post-execution of the outer function.

function outerFunction() {
    let outerVariable = 'I am outside!';

    function innerFunction() {

    return innerFunction;

let globalVariable = outerFunction(); 

globalVariable(); // Logs: "I am outside!"
console.log(outerVariable); // ReferenceError: outerVariable is not defined

In the provided incorrect example, the developer attempts to directly access outerVariable and runs into a ReferenceError. Here's why: the outerVariable lives only within the outerFunction and the lexical environment of innerFunction(), NOT in the global scope or the globalVariable scope. So, outerVariable is reachable only within the closure function innerFunction(), which is returned by outerFunction() and stored in globalVariable.

Understanding both high-order functions and closures is pivotal in grasping advanced JavaScript concepts like currying and partial applications. Higher-order functions and closures not only share theoretical links but are also deeply interconnected in real-world situations. For instance, in functional programming, a popular JavaScript paradigm, we heavily use patterns that lean on these concepts. Understanding these patterns aids in structuring our code more efficiently and readably.

An Introduction to Currying in JavaScript

Currying, derived from mathematical logic, is a powerful tool in JavaScript. This technique involves converting a function that accepts multiple arguments into a series of functions, each handling a single argument. This transformation can lead to greater readability, maintainability, and reusability of your code, factors highly valued in the world of JavaScript development.

Consider a common JavaScript function:

function add(a, b) {
    return a + b;
console.log(add(1, 2)); // Outputs: 3

Through currying, we can decompose the add operation into a sequence of functions, each working with a single argument:

function curriedAdd(a) {
    return function(b) {
        return a + b;
console.log(curriedAdd(1)(2)); // Outputs: 3

In the given example, curriedAdd is a higher-order function that produces another function when invoked. Thus, when you invoke curriedAdd, it gives you a new function adept at taking one argument and calculating the sum of that argument and the initial one supplied to the outer function.

However, one must exercise caution when using curried functions. Often, beginners mistake them for regular functions and attempt to pass all arguments at once. This misunderstanding can lead to unexpected outcomes:

// Incorrect usage of currying
console.log(curriedAdd(1, 2)); // Outputs: function

// Correct usage of currying
console.log(curriedAdd(1)(2)); // Outputs: 3

As observed, when trying to supply both arguments together in curriedAdd(1, 2), you get a function rather than the anticipated result. That's because, in JavaScript, passing two arguments to a curried function, which is designed to receive one argument at a time, only retains the first argument while discarding the second. This discrepancy results in outputting a function instead of a numerical result. The correct approach is to successively invoke each function in the chain, passing one argument at a time, as demonstrated with curriedAdd(1)(2).

Now, consider a real-world application of currying. Let's say you're developing an online store where products need to be sorted in various ways, such as by price, rating, number of reviews, etc. Here is how you could define your product objects:

// Example product object
var allProducts = [
        name: 'Winter Jacket',
        price: 99.99,
        reviews: 123
    // More product objects

Then, you would create a curried function to sort your products:

function sortProduct(sortBy) {
    // This function returns another function that sorts a product array by the specified property
    return function(products){
        return products.sort((a, b) => a[sortBy] - b[sortBy]);

Once you've set up your sortProduct curried function, you can use it to create more functions tailored to sort by specific product properties:

var sortByPrice = sortProduct('price');
var sortByReviews = sortProduct('reviews');

// Now use the created functions across your application
var cheapFirst = sortByPrice(allProducts);
var mostReviewedFirst = sortByReviews(allProducts);

In this code, the sortProduct function doesn't perform the sorting itself. Instead, it generates new functions that are equipped to sort products by any property.

When working with curried functions, it's crucial to continually scrutinize their utility. Is this simplifying the code? Does it make the code more efficient and adaptable for varying inputs and scenarios? If your curried function helps other developers understand, reuse, or modify your code, or if it reduces the overall complexity of your software, you've probably made a judicious choice in employing currying!

Understanding Partial Application in JavaScript

What is Partial Application?

Partial application is a technique in functional programming where we create a new function by pre-setting some of the arguments of the original function. This directly leads to enhanced reusability and modularity of code, as the partially applied function can be reused with different argument sets.

Now, let's take a look at an example to illustrate the concept.

// Original function
function multiply(a, b) {
    return a * b;

// Partially applied function
const double = multiply.bind(null, 2);

console.log(double(5));  // Outputs 10

In the above example, multiply is our original function. We create a new function, double, by fixing the first argument of multiply to 2. Now, double is a function of one argument that multiplies its input by 2.

Partial Application Pros & Cons

Performance: Since partial application generates a new function, there is a slight execution time overhead in the creation process. However, the performance difference is often negligible in day-to-day development and acceptable for the benefits it provides.

Memory: Again, because a new function is generated for each partial application, there could be more memory usage compared to the non-partially applied function, especially if you are creating numerous instances. Yet, in many cases, this isn't a significant concern.

Complexity/Readability: Partial application can initially increase the complexity of the code for those unfamiliar with the concept. However, once getting used to it, it drastically enhances readability and simplicity. The code becomes more declarative and intentions much clearer.

Reusability/Modularity: This is where partial application truly shines. Partial applications can make code more modular and promote reusability. A function intended for a general purpose can be partially applied to create more specific uses, enhancing the modularity in the codebase.

Best Practices & Common Mistakes

One typical mistake is misusing partial application, which can lead to numerous bugs in the code. This issue is often due to misapplication, resulting in functions that do not behave as expected.

Here's an incorrect example of partial application:

// A common mistake: misunderstanding partial application.
function sum(a, b, c) {
    return a + b + c;

let partialSum = sum.bind(null, 1);

console.log(partialSum(2, 3));  // Outputs NaN

In this case, partialSum expects to be a function of two arguments (b and c), but it’s given two arguments after already binding 1 to a of sum. This results in NaN.

Here's the corrected code snippet:

// Correct way: proper use of partial application.
function sum(a, b, c) {
    return a + b + c;

let partialSum = sum.bind(null, 1, 2);

console.log(partialSum(3));  // Outputs 6

In this correct example, we adhere to the basic principle of partial application: generating a new function by pre-setting some of the parameters of the original function. The bind method makes this possible.

So, think about this: have you ever come across certain code blocks that seemed overly complex and could have been simplified with partial application? Or perhaps you've been wisely using this technique without fully understanding what it is? Understanding the concept behind the solutions we use enhances our ability to make decisions about their application, and a thorough understanding of JavaScript techniques like partial application can certainly contribute to cleaner and more efficient code.

Distinguishing Between Currying and Partial Application

Before delving into the distinguishing aspects, it's crucial to understand that both currying and partial application share a common goal: transforming a function that accepts N arguments into a sequence of functions which each accept a single argument (arity of one). Despite this shared objective, they employ different tactics and are each useful in unique situations.

Currying in JavaScript

Currying is the technique of converting a function with multiple arguments into a sequence of functions each with a single argument. The last function in the sequence returns the result. Let's illustrate with a code example.

function curryAdd(a) {
  return function(b) {
    return function(c) {
      return a + b + c;
const sum = curryAdd(1)(2)(3);  // returns 6

The currying advantage is you can easily create new functions by fixing some of the arguments to the function.

However, watch out for the downside: overly-curried functions can lead to a lot of chained calls and can subsequently harm readability. As developers, we must aim for code that is not just efficient, but also readable and maintainable in the long term.

Preferred Syntax: (a)(b)(c)...(n), where each () is a separate function call in the currying sequence.

Habitual Mistake: Overly using currying may lead to a 'pyramid of doom' and make code hard to read and understand.

Correct Practice: Use currying when it is suitable but keep readability in mind.

Partial Application in JavaScript

In contrast, partial application implies fixing a number of arguments to a function, creating a new function of smaller arity. Here is how you can partially apply functions in JavaScript.

function partialAdd(a, b) {
    return function(c) {
        return a + b + c;
const partialSum = partialAdd(1, 2); // Returns a function
console.log(partialSum(3));  // Returns 6

The major advantage of partial application is that it allows us to create functions on-the-fly with some parameters pre-filled and use them later with the remaining parameters.

The disadvantage comes with trying to partially apply parameters which are not at the beginning of a function's parameter list. This requires a workaround to apply non-leading arguments and can thus add complexity to the code.

Preferred Syntax: (a, b)(c)...(n), where (a, b) are the leading parameters and (c)...(n) are the remaining parameters.

Common Mistake: Trying to partially apply parameters not in the beginning of a function's parameter list making code complex and difficult to figure out.

Correct Practice: When applying partial arguments, ensure they are at the beginning of the function's parameter list to keep your code clean and straightforward.

Performance Implications and Final Thoughts

When it comes to performance, both currying and partial application pose an overhead cost over plain function calls due to the additional closures and function calls involved. However, this is typically negligible unless inside performance-critical code paths.

So, which is better? It's context-dependent. The choice between currying and partial application doesn't have to be exclusive. You can use both in the same codebase, depending on the requirements and use cases.

In essence, both currying and partial application in JavaScript are potent tools in a developer's kit when dealing with functional programming. In the right spot, each of these techniques can significantly enhance your code's functionality, maintainability, and reusability. Optimize these techniques to your advantage and avoid the stated mistakes for best practices.

Advanced JavaScript Concepts: From Function Composition to Interview Scenarios

Building upon the previous sections, let's now delve into the relationship between currying and some other advanced JavaScript concepts. For instance, function composition and partial functions are among these pivotal elements of modern web development that are closely tied with currying in JavaScript.

Relevance of Currying in Function Composition

Function composition is a fundamental concept in functional programming. In JavaScript, we achieve this by combining two or more functions to create a new function. Now, you might be asking, what does currying have to do with function composition?

The answer lies in the way currying transforms a function. By breaking down a function that takes multiple arguments into a series of functions that each take a single argument, we create an environment ripe for function composition.

Consider this coding example:

function compose(f, g) { 
    return function (x) { 
        return f(g(x)); 

const square = x => x * x;
const double = x => x * 2;
const squareAfterDoubling = compose(square, double);

console.log(squareAfterDoubling(5)); // outputs: 100

The compose() function returns a function that represents the composition of f and g. Note how the call squareAfterDoubling(5) allows one function to be executed after another, enhancing readability and modularity.

Common mistakes during function composition usually revolve around the order of execution. Developers may forget that the execution order is from the innermost function to the outermost. Notice that our function squareAfterDoubling actually doubles before squaring—not the other way around.

Currying and Closures

Currying works hand in hand with closures in JavaScript. A closure is a function that has access to its own scope, the outer function’s scope, and the global scope. When you curry a function, it returns a new function waiting for the rest of the arguments. These remaining calls make use of closures to remember values of the arguments for later.

Let's illustrate this by currying a function multiply():

function multiply(x, y, z) {
    return x * y * z;

function curry(f) {
    return function (a) {
        return function (b) {
            return function (c) {
                return f(a, b, c);

const curriedMultiply = curry(multiply);
console.log(curriedMultiply(2)(3)(4)); // outputs: 24

You can see in our curry() function that a new scope is created every time a new function is returned. Here, closures come into play to remember the values of a, b, and c for each respective scope.

A common mistake while using closures is not understanding how they manage variables. Misunderstanding may result in overwriting or accessing the incorrect variables and producing incorrect results.

Preparing for Interviews with Currying

While preparing for JavaScript interviews, it's not uncommon to come across problems that involve currying. Being able to demonstrate an understanding of currying, particularly in connection to other advanced concepts, makes you stand out as a developer.

Here's a potential interview question: Write a function subtract(x, y) in JavaScript and implement it using currying.

Here's one way to achieve this:

function subtract(x) {
    return function(y) {
        return x - y;

const subtractFive = subtract(5);
console.log(subtractFive(3)); // outputs: 2

Note that with each nested function, its returned function is promptly stored in another function (subtractFive), which then await the remaining argument to execute correctly.

One common interview pitfall for developers is overcomplicating currying problems. Many candidates fall into the trap of designing unnecessarily complex currying functions. Remember, simplicity and readability are often key in solving these problems.

Hopefully, this discussion has deepened your understanding of currying. The goal is to grasp how it interacts with other elements of JavaScript, such as function composition and closures. Ultimately, recognizing how this concept ties into real-world scenarios can improve your JavaScript problem-solving skills substantially.


In this comprehensive guide, we began with an in-depth discussion on higher-order functions and closures in JavaScript - both serving as stepping stones to understanding advanced concepts like currying and partial application. Currying, a technique originating from mathematical logic, breaks down a traditional function that accepts multiple arguments into a series of individual functions each dealing with one argument. Partial application, on the other hand, involves creating a new function by pre-setting some of a function's arguments. Both techniques serve to make your code more efficient, readable, maintainable, and reusable.

Currying and partial application, despite having a common objective, are indeed suited for different situations which was highlighted through relevant code examples and discussing common mistakes. Understanding and distinguishing these techniques are pivotal when it comes to dealing with real-world coding scenarios, from function composition to job interviews. To further solidify your knowledge, try implementing reusability with currying and partial application on a set of functions that manipulate arrays; whether it be sorting, filtering, or reducing. Reflect on the benefits these techniques bring, and discuss their drawbacks and when not to use them.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers