Currying in JavaScript: The Secret Sauce of Functional Programming

 

Ever been haunted by the question, “Why does JavaScript have functions that seem to take forever to get all their arguments?” Welcome to the fascinating world of currying! If you’ve ever come across code with functions inside functions, that’s probably currying at work — a game-changing technique in functional programming.

Let’s dive into what currying is, why it’s powerful, and where it can be used practically.

What is Currying?

Currying is a technique in functional programming that transforms a function with multiple arguments into a series of functions, each taking just one argument. Rather than passing all arguments at once, you provide them one at a time, allowing each function in the series to return another function that takes the next argument. Once all arguments are provided, the final function in the chain returns the result.

For instance, instead of writing:

function area(length, breadth) {
    return length * breadth;
}

console.log(area(2, 5)); // 10

With currying, it becomes:

function areaCurry(length) {
    return function (breadth) {
        return length * breadth;
    }
}

console.log(areaCurry(2)(5)); // 10

Here, areaCurry(2) returns a new function that takes breadth as a parameter, and then calculates the area when called with breadth.

Currying becomes even more powerful with more complex functions:

function volumeCurry(length) {
    return function (breadth) {
        return function (height) {
            return length * breadth * height;
        }
    }
}

console.log(volumeCurry(2)(5)(6)); // 60

Here, each parameter is passed in sequentially, with the final result being calculated only after all arguments are provided.

Why Use Currying?

1. Reusability: Currying allows you to create partially applied functions easily. Once you call areaCurry(2), for example, you have a reusable function that calculates the area for a length of 2.

const areaForLength2 = areaCurry(2);
console.log(areaForLength2(5)); // 10
console.log(areaForLength2(10)); // 20

2. Function Composition: Currying enables function composition, a key advantage in functional programming. When functions are “curry-able,” you can more easily combine and reuse them.

3. Code Readability: Currying promotes cleaner code, where each function has a specific task. This can make debugging and testing simpler since each function is isolated and doesn’t depend on external variables.

4. Delayed Execution: Currying also enables delayed execution. By breaking down the function, you control when and how each part executes, making your code flexible.

Real-World Examples of Currying

Example 1: URL Builder

Imagine a function to build URLs dynamically. Currying makes it straightforward and customizable.

function createURL(domain) {
    return function (path) {
        return function (params) {
            const query = Object.entries(params)
                .map(([key, value]) => `${key}=${value}`)
                .join("&");
            return `https://${domain}/${path}?${query}`;
        }
    }
}

const googleSearchURL = createURL("google.com")("search");
console.log(googleSearchURL({ q: "JavaScript Currying", page: 1 }));
// "https://google.com/search?q=JavaScript%20Currying&page=1"

Here, createURL is a curried function that takes each part of the URL step-by-step. This allows for highly customized URLs with minimal code!

Example 2: Discount Calculator

Currying is ideal for setting up modular discount functions. Suppose we run a store and want a 10% discount on specific items.

function applyDiscount(discount) {
    return function (price) {
        return price - (price * discount);
    }
}

const tenPercentDiscount = applyDiscount(0.10);
console.log(tenPercentDiscount(100)); // 90
console.log(tenPercentDiscount(250)); // 225

With currying, you create tenPercentDiscount as a reusable function for consistent discounts across items. No need to redefine discounts each time!

Example 3: Authentication Middleware

In frameworks like Express.js, currying can help create modular, composable middleware.

function auth(role) {
    return function (req, res, next) {
        if (req.user.role === role) {
            next();
        } else {
            res.status(403).send("Access denied");
        }
    }
}

// Usage example
app.get("/admin", auth("admin"), (req, res) => {
    res.send("Welcome, Admin!");
});

Here, auth("admin") returns a middleware function that checks if the user has the admin role. By currying, we can create specific authorization functions for various roles without repeating code.

Wrapping Up

Currying may seem like just another fancy functional programming trick, but it’s a powerful pattern that offers significant benefits: cleaner code, reusability, and efficient composition. Whether you’re dynamically building URLs or setting up custom middleware in Express, currying is there to help!

Ready to take advantage of currying in your own code? Try refactoring your functions, break down tasks, and watch your JavaScript code get cleaner, modular, and more efficient!