DEV Community

loading...

Currying Function and It's Advantages

iamawaisakram profile image Awais Akram Mughal ・2 min read
  • Turning a function that takes multiple arguments, to a function which returns functions (Unary and Anonymous).

  • Currying is right-associative (Read from Right-Left).

  • The concept acts systematic: Property needs to interact with other basic properties in order to fully develop its advantages. There is a mutual dependency between the properties involved.

  • Makes working with HOC(Higher Order Component) much more effective, provided the passed in functions are in curried form themselves.

Let's Look at an Example:

// * Abstraction over Arity(the amount of functions you can curry into one function)

const comp = f => g => x => f(g(x));
const inc = x => x + 1; // * Unary Function
const mul = y => x => x * y; // * Binary Function

// * Normal Composition of two unary Functions:
comp(inc)(inc)(2); // * 4

// * Composition of Binary and Unary Funtions:
comp(mul)(inc)(2)(3); // * 9

// * Invalid Composition of an inner binary Function:
comp(inc)(mul)(2)(3); // * Type Error

Let's look at the Invalid Composition Example:

  • Here, f's arity doesn't matter, because "comp" is polymorphic in nature/return.

  • If f is substituted with inc, comp's return type becomes:

x => f(g(x))
  • If f is substituted with mul, comp's return type becomes:
x => y => f(g(x))(y)

Which is perfectly valid. However, mul here is g and it requires 2 arguments but only one is given, hence, type error.

Important Things to note here:

  • Arguments Order matters, it only concerns non-commutative functions.

  • Primary parameters should be placed at the end to facilitate function composition.

  • Parameters that are least likely to change should be place leftmost to facilitate partially applied functions.

DON'T:

  • Rely on function's length property.

  • Use magic auto currying, that is, functions as return values are curried automatically.

Discussion (0)

pic
Editor guide