Its all about closures. Different complexFunctions has its own calls variable becouse of closure enviroment.

Being new to javascript I didn't understand how this worked for different complexFunctions. Looking into scoping of variables led me to javascript closures and it all makes sense now.

Tried to pull this off with a simple comparision:

calls[key] !== undefined

the problem with this approach was that cached functions could return any value (including undefined value), so there's no way to discern yet uncached function calls from cached function calls that returned undefined. So far I thought that

!(key in calls)

is semantically equivalent to simple comparision mentioned above. I was wrong because this approach can handle the job and discern unset undefined from set undefined. Thanks for casting some light on this subtlety.

Here's some sample code to demonstrate...

function MyObj(myvar) {
  this.myvar = myvar;
  console.log("this.myvar is " + this.myvar);
  if (this instanceof MyObj) {
    console.log("Called as constructor: new MyObj(...)");
  } else {
    console.log("Called as an ordinary function: MyObj(...)");
  }
  return this;
}
MyObj.prototype.method1 = function () {
  console.log("this.myvar is " + this.myvar);
  if (this instanceof MyObj) {
    console.log("method1 was called on a MyObj object");
  } else {
    console.log("Error: method1 must be called on a MyObj object");
  }
};

Now we test it...

If we call it as a function, this is the global object and it can access global variables as properties of it:

MyObj("foo"); // call as function
// "this.myvar is foo"
// "Called as an ordinary function: MyObj(...)"

And now since it's this was the global object, myvar has leaked outside of the function:

console.log(myvar);
// "foo"

If it's called as a constructor (like it's supposed to be), its this is the MyObj object you've constructed, with its own myvar property (and now nothing leaks into the global, so the global myvar would still be "foo" afterward):

var myobj = new MyObj("bar"); // call as constructor
// "this.myvar is bar"
// "Called as constructor: new MyObj(...)"

Now, since we've created a new MyObj object named myobj, what about the method1 function?

Ordinarily, if you call myobj.method1, its this value will be myobj:

myobj.method1();
// "this.myvar is bar"
// "method1 was called on a MyObj object"

If you create an alias of the method, it becomes orphaned from its parent object and it doesn't work anymore (and its this is the global object, so this.myobj is the global that had been defined above):

var fn1 = myobj.method1; // fn1 is orphaned from its myobj object; its this is the global object
fn1(); // it can access the global because it's not bound to anything
// "this.myvar is foo"
// "Error: method1 must be called on a MyObj object"

Now, if you bind the method to itself, its this is itself, and it doesn't work; also, since method1 doesn't have any property named myvar, this.mybar will be undefined:

var fn2 = myobj.method1.bind(myobj.method1); // now it's bound to itself
fn2(); // it can't access the global now; it's bound to itself
// "this.myvar is undefined"
// "Error: method1 must be called on a MyObj object"

Last, the correct way, by binding it to the myobj object, which results in the same thing as calling myobj.method1() does:

var fn3 = myobj.method1.bind(myobj); // it's bound to its myobj, so it's not an orphan
fn3();
// "this.myvar is bar"
// "method1 was called on a MyObj object"

First of all, if func doesn't use the this value, then it doesn't matter what the first argument is. It can be anything because it's never used.

Secondly, inside of a function, this is never ordinarily the function itself. It's one of two things:

• the global this object
• an object you've created using new

So you generally never need to call func.bind(func), because func would not normally expect itself to be its own this object. And when you need to bind an object of a class to one of its methods, you write obj.method.bind(obj) so that the method is bound to the object. You wouldn't write obj.method.bind(obj.method).

First argument in call, according to documenation is "this" for the function. That allows you to write complex constructors.

Why do you need to pass null as first argument to apply? I thought you'll need to pass func as first argument.

Thanks,

Indeed. I have a solution which generates a valid pass1, I believe a valid pass2, and a proper pass3, but I can't submit because this first test-case is too strict.

Test driven development at its finest.