js - Higher order unary function - why is this needed?

Question

Here's where it starts: This below snippet doesn't work as expected:

['1', '2', '3'].map(parseInt)           // [1, NaN, NaN] <- bad output

A simple change remedies it:

['1', '2', '3'].map(a => parseInt(a))   // [ 1, 2, 3 ] <- good output

But this book I'm reading has a different remedy:

Create a unary function, which takes in a function (parseInt in our case) and if the function has n arguments, it returns a new function that has only a single argument. Here's how the book does it:

const unary = (f) => {
  return f.length === 1 ? f : (args) => f(args)
}

['1', '2', '3'].map(unary(parseInt)) // [ 1, 2, 3 ] <- good output again!

My question is:

1. How is this unary function is working?
2. Any practical scenario where this function (or at least this idea in general) will find a good use?

Any help would be much appreciated :)

---

Note to the future reader: Checkout currying

Answer 1

How is this unary function is working?

The length of a function is how many declared non-rest parameters it has prior to the first parameter with a default value*. So unary works by seeing if the function claims to accept just one parameter and if so returning the original function, and if not by creating a new function that only ever calls the original with one argument.

This check is not reliable and I wouldn't use that version of unary. Lots of functions change their behavior based on how many actual arguments they get, even if they only declare one.

Any practical scenario where this function (or at least this idea in general) will find a good use?

A version that always did the wrapper (without looking at length) could be handy for situations just like your parseInt one: You want to call the other function with only X arguments (1, in your case), regardless of how many are supplied to your callback.

This kind of thing is quite common in functional programming. If you're not doing functional programming in general, then probably in these days of arrow functions it wouldn't have much use. But a fair number of people use JavaScript in the functional way.

---

* Yes, it's that complicated. Examples (requires a browser with support for ES2015 [aka "ES6"] default parameter values and rest parameters):

function a(one) { }
function b(one, two) { }
function c(one, two, ...rest) {}
function d(one, two = 42, ...rest) {}
function e(one, two = 42, three) {}
console.log(a.length); // 1
console.log(b.length); // 2
console.log(c.length); // 2
console.log(d.length); // 1
console.log(e.length); // 1

Answer 2

in this unary function, fn.length is checking the arguments length of parseInt, if the parseInt have only one arguments then it return the function as usual. but in this scenario, we have got 2 arguments in parseInt which is parseInt(value ,radix) so our fn.length === 1 failed. if it have 2 arguments then it return the parseInt with one argument which is value only. eg parseInt(value) not parseInt(value, radix)

Answer 3

How is this unary function is working?

The length property on a function returns the number of formal parameters that a function has*. The unary function checks whether the function has one formal argument. If so, it just returns the original function. If not, it returns a new function that takes a single parameter, passes it to f, and returns the result.

Any practical scenario where this function (or at least this idea in general) will find a good use?

As shown in the example, there are certain functions that change their behavior depending on how many arguments are passed into it. Often (such as when you're using .map), you really just want to pass in one argument, and unary() helps with that.

---

_{* Or at least it used to. With the release of ES6, it's more complicated now. See T.J. Crowder's answer for details.}