JavaScript Currying: What it is and why you need it?

Currying is a technique in which a function is called with fewer arguments than it is defined to accept. When a function is called with fewer arguments than it expects, it returns a new function that expects the remaining arguments. This new function is called a curried function.

To understand the concept of currying, let's first consider a simple example of a normal function that adds two numbers. Here is the code for this function:

  function add(x, y) {
    return x + y;
  }

  let result = add(1, 2); // returns 3

Now let's convert this function to a curried function. Here is the code for the curried version of the add function:

  function add(x) {
    return function(y) {
      return x + y;
    }
  }

  let add3 = add(3);
  let result = add3(4); // returns 7

As you can see, the curried version of the add function expects a single argument x, and returns a new function that expects a single argument y. When this new function is called with an argument y, it returns the sum of x and y.

The main difference between the normal add function and the curried version is that the normal function expects all of its arguments at once, while the curried function expects its arguments one at a time. This can be useful in a variety of situations. For example, you might want to create a function that always adds a certain value to its input, or a function that expects a fixed set of arguments and is easier to reason about.

To make it easier to curry any function, you can write a generic curry function that takes a function and returns a curried version of that function. Here is an example of such a curry function:

  function curry(fn) {
    return function curried(...args) {
      if (args.length >= fn.length) {
        return fn.apply(this, args);
      } else {
        return function(...args2) {
          return curried.apply(this, args.concat(args2));
        }
      }
    }
  }

This curry function takes a function fn as an argument and returns a new curried function. The curried function expects any number of arguments, which are passed to it as an array using the spread operator (...args).

If the number of arguments passed to the curried function is greater than or equal to the number of arguments expected by fn, the curried function calls fn with the given arguments. Otherwise, it returns a new function that expects the remaining arguments.

Curried functions can be useful in a variety of situations. For example, you might want to create utility functions that can be customized for specific use cases, or you might want to create functions that have a fixed set of arguments and are easier to reason about.

In conclusion, currying is a powerful technique that allows you to create customized functions by calling a function with fewer arguments than it expects. This can be useful in a variety of situations, and is a useful tool to have in your Javascript toolkit.

---

---