Clarify implementation reasoning

[medikoo]

I just approached this package, and was a bit puzzled over it's complexity. To my understanding check for "is callable" in ES5+ world is as simple as typeof value === 'function'.

What do I miss? Are there any new ES2015+ introductions that do not fall into that rule (class, async function, arrow function return 'function' as expected)

• Are there any cases in ES5+ world, where a callable value will not return 'function' for typeof check
• Are there any cases in ES5+ world, where non callable value will return 'function' for typeof check?

I'll be grateful for clarification.

[ljharb]

Regular expressions in older browsers have a typeof value of "function".

Some native host objects return typeof function, but are not actually functions.

Separately, classes are not callable - so although there's no way to accurately detect this (sadly), typeof class Foo {} === 'function' but you can only construct it.

In other words, when typeof is not "function" it's definitely not callable (see the bailout here), but when it is function, there's more checks that need to be done.

[medikoo]

Regular expressions in older browsers have a typeof value of "function".

Sure, but they're callable :) you can do regex(foo) and it will work

Some native host objects return typeof function, but are not actually functions.

They're also callable, and work with all native functions (e.g. [].forEach) that expects functions.

To my understanding callable is any object which has internal [[Call]] slot, and above two fall into that.

Separately, classes are not callable - so although there's no way to accurately detect this (sadly), typeof class Foo {} === 'function' but you can only construct it.

They crash when not invoked with new, but I'd say it's a characteristics of validation mechanism.
I take class syntax as only a sugar, and what we really receive is a typical function, just with some extra behaviours. Additionally in ES2015+ there are class constructors that do not crash, and can be called without issues as Constructor() (e.g. Array).

Anyway thanks for explanation, it's clearer for me, on why you decided on such route.

[ljharb]

True, you are correct that those regexes are callable :-) this module started as "is-function" and ended up a bit more generic.

class is not merely syntax sugar - a class constructor genuinely lacks a [[Call]] slot, so it's not the same as a function that throws when new.target is undefined.

typeof foo === 'function' is quite safe for most use cases :-)

[medikoo]

a class constructor genuinely lacks a [[Call]] slot

Not true, if it wouldn't have that slot, any try to do Constructor() will crash with TypeError: Constructor is not a function, additionally in such case typeof Constructor per spec could not return 'function'

After looking more thoroughly into ES2015 spec, I must say that this package is very confusing, especially that it doesn't reflect native ECMAScript isCallable behavior.

[medikoo]

The only valid argument I see here, is that it might be helpful to reject class constructors (for scenarios when we indeed expect plain functions). Still, first it will have to be confirmed whether there's a solid method to detect such constructors without false positives, I'm not sure if that's possible (?)

I would also definitely rename this package to something as e.g. is-plain-callable (or is-plain-function if you wish to also reject non-function instances), as it's certainly not about isCallable as we know it from ES or user land (e.g. some other old isCallable implementation, from ES3 era, when we dealt with callable host objects which returned 'object' for typeof check)

[ljharb]

Thanks for the suggestion - I'm going to keep the name as-is.

[aikar]

@ljharb I would suggest putting this explanation at the top of the readme, as I'm sure many are confused on what is the point of this. I at least looked at closed issues :)