[Ramda] Curry and Uncurry Functions with Ramda

Most of the functions offered by the ramda library are curried by default. Functions you've created or that you've pulled in from another library may not be curried. Ramda's

curry

and

curryN

functions allow you to take a non-curried function and use it as a curried functions. In the case where you have a manually curried function and you want to just call it like a normal function, you can use

uncurryN

to get back a function that accepts all of the arguments at once.

What is manully curry?

const add =  a => b => a + b;

When we call it, we should do:

add(1)(2);

or

const inc = add(1);
const res = inc(2);

What is R.curry?

const add = R.curry((a, b) => a + b);

when we all this, we can do:

const inc = add(1);
const res = inc(2);

or:

add(1,2)

So the main difference between R.curry and manully curry function is R.curry allow user pass all the params necessary at once. But manully curry, you have to invoke the function twice.

R.curryN:

Actually R.curryN is basiclly the same as R.curry. Just it tells how many params the curry function should expect.

var sumArgs = (...args) => R.sum(args);

var curriedAddFourNumbers = R.curryN(4, sumArgs);
var f = curriedAddFourNumbers(1, 2);
var g = f(3);
g(4); //=> 10

So in the example, it has 4 params.

R.uncurryN:

It is used for manully curry, so that we don't need to invoke function multi times, just pass all the params which necessary at once.

const add = a => b => c => a + b+ c; // manually curry

// if we call normally
add(1)(2)(3);

// if we uncurry it
const sum = R.uncurryN(3, add);
const res = sum(1,2,3); // 6