Closures and curries

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


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:
notion image


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 it’s a funcitonal javascript functions based on curry functions
You can try Ramda functions here: