Necessity of a syntax construct for bind

David Bruant david.bruant at
Sat Sep 3 11:21:05 PDT 2011

Le 31/08/2011 19:56, Michael Ficarra a écrit :
> This is my first reply on es-discuss, so my apologies if I've done
> something incorrectly and this doesn't get properly routed.
> David and Lasse, I'd like to direct you
> to and, in particular, pull
> request #43:
> In that series of commits, I removed all runtime dependence on the
> environment and bootstrapped Function.prototype.bind while relying
> only on the existence of at definition time
> and with no dependencies at runtime. This allows me to call any
> function using `call(functionName, thisArg, argument0, argument1,
> ...)`. I also used that to bootsrap a similar `apply` function. The
> general idea behind bootstrapping a bind method was to make a sub-par
> `call` and `apply` implementation that relied on
> ``, but replacing them after defining bind
> by using our new bind method similarly to how you suggested. It'd
> probably be easier to just read the code, though, than have me
> continue trying to explain it.
So if I understand correctly, the relevant part of code to remove the
dependency to the runtime is the following:
var nativeCall =;
var nativeApply = Function.prototype.apply; = nativeCall; // adding an own "call" property to the
native call

// assuming there is no native bind
var apply = function (fn, context, args) {
    return, fn, context, args);
     call = function (fn, context) {
    return apply(fn, context,,
arguments, 2));

Function.prototype.bind = function bind(that){
  // no dependency on runtime
  // but dependency on runtime
  // and dependency on runtime variable "call"

call =, nativeCall);
apply =, nativeApply);
The idea of defining an own "call" property to nativeCall is
interesting, because it indeed allows to do without
depending on redefinition of
However, it only shifts the problem to the runtime value of (all dots refer to an own property, even
the last one). In order to protect yourself from this dependency, you
could define as non-writable and non-configurable (in
platforms allowing this).
Another idea would be to remove your dependency to and
replace it with only "call" (which at the end is a new function which no
one should have access to unlike

Regardless, the dance where you first define a call function, use it to
define Function.prototype.bind, use bind to redefine call to make it
independent of other things is a very interesting move!



> Michael Ficarra
>     ---------- Forwarded message ----------
>     From: David Bruant <david.bruant at
>     <mailto:david.bruant at>>
>     To: Lasse Reichstein <reichsteinatwork at
>     <mailto:reichsteinatwork at>>
>     Date: Wed, 31 Aug 2011 11:28:54 +0200
>     Subject: Re: Necessity of a syntax construct for bind
>     Le 31/08/2011 10:52, Lasse Reichstein a écrit :
>>     On Tue, Aug 30, 2011 at 11:46 PM, David Bruant
>>     <david.bruant at <mailto:david.bruant at>> wrote:
>>         Le 30/08/2011 21:59, Lasse Reichstein a écrit :
>>>         A reliable .call could probably also achieve the same.
>>         A reliable .call could be achieved by composing a reliable
>>         .bind and the function call syntax.
>>     True. The Bind operation is the currying of the Call operation. 
>>     Ah, that got me thinking. I can do
>>       var CallFunction =
>>     since bind does give a different way to set the this-object for a
>>     call. This can be done once, before anybody gets to mangle the
>>     builtins, and can be stored for afterwards. Excellent!
>     Brilliant!
>     Of course, it requires a native Function.prototype.bind, but
>     that's brilliant!
>     David
> _______________________________________________
> es-discuss mailing list
> es-discuss at

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list