The act of currying can be described as taking a multivariate function and turning it into a series of unary functions.

Let's see an example:

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

const inc = add(1);

const res = inc(3) //

This is a very basic currying example.

We wrote a function 'add' take a param 'a' return a function which take param 'b', finally return a + b;

We can based on 'add' function to create another function 'inc'. This approach is good for resuability. But there is one problem, because you cannot do:

add(1,3)

To solve the problem we need to write a 'curry' function, the basic idea is:

1. Check the passed in function, how many params it should takes, in our case 'add' function take 2 params.

2. 'curry' should return another function, inside function it should check, if length of params is the same as function's params, in our case is:

add(1,3)

Then we invoke function immediately. (Using .call for immediately invoke)

3. Otherwise, we should still return a function with param partially applyied. (using .bind for partially apply)

function curry(fn) {

  // The number of fn's params

  // fn = (a, b) => a + b

  // then length is 2

  const arity = fn.length;

  console.log(arity)

  return function $curry(...args) {

    console.log(args, args.length)

    if (args.length < arity) {

      // partially apply

      // in case of add(1)(2)

      return $curry.bind(null, ...args);

    }

    // immediately invoke

    // in case of add(1,2)

    return fn.call(null, ...args);

  };

};

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

const inc = add(1);

const res = inc(2) //

Arity describes the number of arguments a function receives. Depending on the number it receives, there are specific words to describe these functions.

A function that receives one is called a unary function.

A function that receives two arguments is called a binary,

three equals a ternary,

and four equals a quaternary,

so forth and so on.