Closures and Curries

Closures and currying are both important concepts in JavaScript, especially for functional programming.

javascript

Closures and currying are both important concepts in JavaScript, especially for functional programming.

Closure

A closure is a function that has access to its outer scope even after the outer function has returned. It “closes over” its outer scope, hence the name. Here’s an example:

function outerFunction(x) {
  return function innerFunction(y) {
    return x + y;
  };
}
const add5 = outerFunction(5);
console.log(add5(3)); // 8

In the above example, **innerFunction** has access to **x** even after **outerFunction** has returned. This allows us to keep state across multiple invocations of the inner function. We can use closures to store a function with a first parameter, you can see an example here:

Curries

Currying, on the other hand, is a technique where we convert a function that takes multiple arguments into a function that takes one argument and returns another function. This allows us to partially apply arguments to a function, making it more composable and reusable. Here’s an example:

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(null, args);
    } else {
      return function (...moreArgs) {
        return curried.apply(null, args.concat(moreArgs));
      };
    }
  };
}
function add(a, b, c) {
  return a + b + c;
}
const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)(2)); // 10

In the above example, we take the **add** function and curry it with the **curry** function. This allows us to partially apply the **5** argument to the **add** function, creating a new function **add5** that takes two arguments instead of three.

const add = function (a, b) {
  return a + b;
};
const curriedAdd = curry(add);
console.log(curriedAdd(1)(2));

The example above of simple carry, its looks like closures but not function inside function

Ramda

Ramda it’s a funcitonal javascript functions based on curry functions

[!info] Ramda Documentation Accepts a converging function and a list of branching functions and returns a new function. https://ramdajs.com/docs/#curry

You can try Ramda functions here: https://ramdajs.com/repl/?v=0.28.0