Try to speed up queue

Reduce number of .then call.
But memory usage increases :/

lib/rsvp/promise.js

@@ -121,7 +121,7 @@ Promise.prototype = {
   then: function(done, fail) {
     this.off('error', onerror);
 
-    var thenPromise = new this.constructor(function() {},
+    var thenPromise = new Promise(function() {},
         function () {
           thenPromise.trigger('promise:cancelled', {});
         });

lib/rsvp/queue.js

@@ -12,92 +12,80 @@ function ResolvedQueueError(message) {
 ResolvedQueueError.prototype = new Error();
 ResolvedQueueError.prototype.constructor = ResolvedQueueError;
 
-var Queue = function() {
-  var queue = this,
-    promise_list = [],
-    promise,
-    fulfill,
-    reject,
-    resolved;
+var last_promise,
+  i;
 
+var Queue = function() {
   if (!(this instanceof Queue)) {
     return new Queue();
   }
 
-  function canceller() {
-    for (var i = 0; i < 2; i++) {
-      promise_list[i].cancel();
+  var queue = this,
+    promise_stack = [],
+    then_stack = [];
+
+  Promise.call(queue, function (resolveQueue, rejectQueue) {
+    var detectQueueSuccess,
+      detectQueueError;
+
+    function handleQueue() {
+      if (then_stack.length === 0) {
+        return true;
       }
+
+      last_promise = promise_stack[promise_stack.length - 1];
+      promise_stack.splice(0, promise_stack.length);
+      for (i = then_stack.length - 1; i >= 0; i -= 2) {
+        last_promise = last_promise.then(then_stack[i - 1], then_stack[i]);
+        promise_stack.push(last_promise);
       }
+      then_stack.splice(0, then_stack.length);
 
-  promise = new Promise(function(done, fail) {
-    fulfill = function (fulfillmentValue) {
-      if (resolved) {return;}
-      queue.isFulfilled = true;
-      queue.fulfillmentValue = fulfillmentValue;
-      resolved = true;
-      return done(fulfillmentValue);
-    };
-    reject = function (rejectedReason) {
-      if (resolved) {return;}
-      queue.isRejected = true;
-      queue.rejectedReason = rejectedReason ;
-      resolved = true;
-      return fail(rejectedReason);
-    };
-  }, canceller);
+      promise_stack.push(
+        last_promise.then(detectQueueSuccess,
+                          detectQueueError)
+      );
+      return false;
+    }
 
-  promise_list.push(resolve());
-  promise_list.push(promise_list[0].then(function () {
-    promise_list.splice(0, 2);
-    if (promise_list.length === 0) {
-      fulfill();
+    detectQueueSuccess = function (fulfillmentValue) {
+      if (handleQueue()) {
+        return resolveQueue(fulfillmentValue);
       }
-  }));
-
-  queue.cancel = function () {
-    if (resolved) {return;}
-    resolved = true;
-    promise.cancel();
-    promise.fail(function (rejectedReason) {
-      queue.isRejected = true;
-      queue.rejectedReason = rejectedReason;
-    });
+      return fulfillmentValue;
     };
-  queue.then = function () {
-    return promise.then.apply(promise, arguments);
+
+    detectQueueError = function (rejectedReason) {
+      if (handleQueue()) {
+        return rejectQueue(rejectedReason);
+      }
+      throw rejectedReason;
     };
 
-  queue.push = function(done, fail) {
-    var last_promise = promise_list[promise_list.length - 1],
-      next_promise;
+    // Resolve by default
+    promise_stack.push(
+      resolve().then(detectQueueSuccess, detectQueueError)
+    );
 
-    if (resolved) {
-      throw new ResolvedQueueError();
+  }, function () {
+    // Cancel all created promises
+    var i;
+    then_stack.splice(0, then_stack.length);
+    for (i = 0; i < promise_stack.length; i += 1) {
+      promise_stack[i].cancel();
     }
 
-    next_promise = last_promise.then(done, fail);
-    promise_list.push(next_promise);
+  });
 
-    // Handle pop
-    promise_list.push(next_promise.then(function (fulfillmentValue) {
-      promise_list.splice(0, 2);
-      if (promise_list.length === 0) {
-        fulfill(fulfillmentValue);
-      } else {
-        return fulfillmentValue;
-      }
-    }, function (rejectedReason) {
-      promise_list.splice(0, 2);
-      if (promise_list.length === 0) {
-        reject(rejectedReason);
-      } else {
-        throw rejectedReason;
+  queue.push = function (done, fail) {
+    if (queue.isFulfilled || queue.isRejected) {
+      throw new ResolvedQueueError();
     }
-    }));
-
-    return this;
+    then_stack.unshift(done, fail);
+    return queue;
   };
+
+  return queue;
 };
 
 Queue.prototype = Object.create(Promise.prototype);