JS Promises - trivial impl.

Promise.js

function Promise(fn) {
  var state = 'pending';
  var value;
  var deferred = null;

  function resolve(newValue) {
    if(newValue && typeof newValue.then === 'function') {
      newValue.then(resolve);
      return;
    }
    value = newValue;
    state = 'resolved';

    if(deferred) {
      handle(deferred);
    }
  }

  function handle(handler) {
    if(state === 'pending') {
      deferred = handler;
      return;
    }

    if(!handler.__onResolved) {
      handler.__resolve(value);
      return;
    }

    var ret = handler.__onResolved(value);
    handler.__resolve(ret);
  }

  this.then = function(onResolved) {
    return new Promise(function(resolve2) {
      handle({                              // from this context
        __onResolved: onResolved,
        __resolve: resolve2                 // from this2 context - the new/next Promise
      });
    });
  };

  fn(resolve);
}

// (A) "Simple" chain: new Promise(fn1).then(fn2).then(fn3);
this1 {
  deffered = {
    __onResolved: onResolved1,  // == "useful payload"
    __resolve: this2.resolve    // == "trigger next"
  }
}
this2 {
  deffered = {
    __onResolved: onResolved2,
    __resolve: this3.resolve
  }
}
this3 {
  deffered : null
}

// (B) Suddenly, fn1() returns a Promise, not a plain value! Then we add the new Promise "before" this1:
newValue {
  deffered = {
    __onResolved: this1.resolve,  // "useful payload" is used to "trigger next", i.e. this1
    __resolve: newValue1.resolve
  }
}
newValue1 {
  deffered : null
}
this1 {
  deffered = {
    __onResolved: onResolved1,
    __resolve: this2.resolve
  }
}
this2 {
  deffered = {
    __onResolved: onResolved2,
    __resolve: this3.resolve
  }
}
this3 {
  deffered : null
}