> Please tell me why you throwing reams of source code in my face is relevant.
Because the bind function implementation shows why it is so slow. If you read the spec like you imply, then reading one function shouldn't be difficult. You can write your own 'bind' function that skips a bunch of uncommon corner cases and get a huge boost in performance. Deal with the possible edge cases and performance tanks.
> Source? Or could it be, shock, that a library that exists for compatibility is targeting environments without a native .bind()?
It's not a matter of supporting older browsers. Babel target's IE9+ by default and has optional polyfills and transformers you must add if you want to support JS versions before ES5.1.
There was a discussion on Reddit about this very topic a few months ago. The poster got served by the Babel guys and deleted all their posts. Their claim was basically that `(foo) => this.foo` should translate into `function (foo) { return this.foo; }.bind(this)` and that Babel got it wrong. The response from sebmck was "There's no point in using bind when you can just remap all references to this which is significantly faster." [source](https://www.reddit.com/r/webdev/comments/30wwgk/an_overview_...).
If you want to know more on the topic, I'd suggest making a github issue so one of their team members can clarify things for you.
> It's only surprising for people who have never tried, never read the spec, and don't understand bind(). The spec clearly states that a bound function cannot be overridden. It's really not that difficult. It would be nice if you could provide clear examples of your problems because you're starting to not make sense.
The spec is fairly obscure about thisArg vs [[BoundThis]] and a full understanding encompasses not only a half-dozen user and internal functions, but also requires the reading about environments. This gets even more opaque in the ES2015 spec. That said, 99.5% of JS programmers will never read the spec (the ES5.1 spec is ~300 pages of extremely technical reading while the ES6 spec is ~600 pages and even harder to understand).
Here's a made-up example
var obj1 = {foo: 3};
var obj2 = {foo: 4};
var add = function (n) { return n + this.foo; }.bind(obj1);
add.call(obj2, 3); //=> 6
This may be easier to see in this little example, but if that definition is somewhere in a library and you use a .call() with a `this` that matters, your function will fail. When you step through with the debugger, you will see that your object that you're passing as the `this` is what you expect. When you step into the function, it will have suddenly changed to a different object.
I assume the silent failure is because users may want to .apply() a function that is bound for the easy array destructuring, but I think that attempting to rebind the `this` too anything but null or undefined should yield an error of some kind.