JavaScript function arity

Function arity is the number of arguments a function expects. While it sounds very theoretical, it's actually quite useful in practice, especially in functional programming.

Getting the arity of a function

The arity of a function can be easily retrieved using Function.prototype.length.

const arity = fn => fn.length;

arity(Math.sqrt); // 1
arity(Math.pow); // 2
arity((x, y, z) => x + y + z); // 3
arity((...args) => args); // 0

As you can see in the example above, the arity of a function is the number of parameters it expects. This is true for regular functions but not for variadic functions. A variadic function is a function that accepts a variable number of arguments. In that case, Function.prototype.length will return 0.

Creating a function with a fixed arity

In some cases, we might want to limit the number of arguments a function can accept. This comes in handy for variadic functions, especially when combined with currying.

Nullary function arity

A nullary function is a function that accepts no arguments. In that case, we can simply call the function without any arguments.

const nullary = fn => () => fn();

nullary(Math.random)(); // 0.6019623086

Unary function arity

A unary function is a function that accepts exactly one argument and can be created by calling the function with just the first argument provided.

const unary = fn => val => fn(val);

['6', '8', '10'].map(unary(Number.parseInt)); // [6, 8, 10]

Binary function arity

A binary function is a function that accepts exactly two arguments. Similarly to the unary function, we can create a binary function by calling the function with just the first two arguments provided.

const binary = fn => (a, b) => fn(a, b);

['2', '1', '0'].map(binary(Math.max)); // [2, 1, 2]

N-ary function arity

In general, a n-ary function is a function that accepts exactly n arguments. Using Array.prototype.slice() and the spread operator (...), we can create a function that will call the provided function with the first n arguments.

const nAry = (fn, n) => (...args) => fn(...args.slice(0, n));

const firstTwoMax = nAry(Math.max, 2);
[[2, 6, 'a'], [6, 4, 8], [10]].map(x => firstTwoMax(...x)); // [6, 6, 10]

Converting array-accepting functions to variadic functions

In some cases, it might be easier to convert a function that accepts an array of arguments into a variadic function. Or, perhaps, we might want to do the opposite. Using the spread operator (...), and rest arguments, this is quite straightforward.

const toVariadic = fn => (...args) => fn(args);
const fromVariadic = fn => args => fn(...args);

const allPromises = toVariadic(Promise.all.bind(Promise));
let p1 = Promise.resolve(1);
let p2 = Promise.resolve(2);
allPromises(p1, p2).then(console.log); // LOGS: [1, 2]

const arrayMax = fromVariadic(Math.max);
arrayMax([1, 2, 3]); // 3