rxjs-rails 2.5.2 → 3.1.0

data/vendor/assets/javascripts/rx.lite.compat.js

@@ -3,46 +3,37 @@
 ;(function (undefined) {
 
   var objectTypes = {
-    'boolean': false,
     'function': true,
-    'object': true,
-    'number': false,
-    'string': false,
-    'undefined': false
+    'object': true
   };
 
-  var root = (objectTypes[typeof window] && window) || this,
+  var
     freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports,
+    freeSelf = objectTypes[typeof self] && self.Object && self,
+    freeWindow = objectTypes[typeof window] && window && window.Object && window,
     freeModule = objectTypes[typeof module] && module && !module.nodeType && module,
     moduleExports = freeModule && freeModule.exports === freeExports && freeExports,
-    freeGlobal = objectTypes[typeof global] && global;
+    freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global;
 
-  if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
-    root = freeGlobal;
-  }
+  var root = root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;
 
   var Rx = {
-      internals: {},
-      config: {
-        Promise: root.Promise
-      },
-      helpers: { }
+    internals: {},
+    config: {
+      Promise: root.Promise
+    },
+    helpers: { }
   };
 
   // Defaults
   var noop = Rx.helpers.noop = function () { },
-    notDefined = Rx.helpers.notDefined = function (x) { return typeof x === 'undefined'; },
     identity = Rx.helpers.identity = function (x) { return x; },
-    pluck = Rx.helpers.pluck = function (property) { return function (x) { return x[property]; }; },
-    just = Rx.helpers.just = function (value) { return function () { return value; }; },
     defaultNow = Rx.helpers.defaultNow = (function () { return !!Date.now ? Date.now : function () { return +new Date; }; }()),
     defaultComparer = Rx.helpers.defaultComparer = function (x, y) { return isEqual(x, y); },
     defaultSubComparer = Rx.helpers.defaultSubComparer = function (x, y) { return x > y ? 1 : (x < y ? -1 : 0); },
     defaultKeySerializer = Rx.helpers.defaultKeySerializer = function (x) { return x.toString(); },
     defaultError = Rx.helpers.defaultError = function (err) { throw err; },
-    isPromise = Rx.helpers.isPromise = function (p) { return !!p && typeof p.then === 'function'; },
-    asArray = Rx.helpers.asArray = function () { return Array.prototype.slice.call(arguments); },
-    not = Rx.helpers.not = function (a) { return !a; },
+    isPromise = Rx.helpers.isPromise = function (p) { return !!p && typeof p.subscribe !== 'function' && typeof p.then === 'function'; },
     isFunction = Rx.helpers.isFunction = (function () {
 
       var isFn = function (value) {
@@ -65,45 +56,59 @@
       return a;
     }
 
-  Rx.config.longStackSupport = false;
-  var hasStacks = false;
-  try {
-    throw new Error();
-  } catch (e) {
-    hasStacks = !!e.stack;
+  var errorObj = {e: {}};
+  var tryCatchTarget;
+  function tryCatcher() {
+    try {
+      return tryCatchTarget.apply(this, arguments);
+    } catch (e) {
+      errorObj.e = e;
+      return errorObj;
+    }
+  }
+  function tryCatch(fn) {
+    if (!isFunction(fn)) { throw new TypeError('fn must be a function'); }
+    tryCatchTarget = fn;
+    return tryCatcher;
+  }
+  function thrower(e) {
+    throw e;
   }
 
+  Rx.config.longStackSupport = false;
+  var hasStacks = false, stacks = tryCatch(function () { throw new Error(); })();
+  hasStacks = !!stacks.e && !!stacks.e.stack;
+
   // All code after this point will be filtered from stack traces reported by RxJS
   var rStartingLine = captureLine(), rFileName;
 
-  var STACK_JUMP_SEPARATOR = "From previous event:";
+  var STACK_JUMP_SEPARATOR = 'From previous event:';
 
   function makeStackTraceLong(error, observable) {
-      // If possible, transform the error stack trace by removing Node and RxJS
-      // cruft, then concatenating with the stack trace of `observable`.
-      if (hasStacks &&
-          observable.stack &&
-          typeof error === "object" &&
-          error !== null &&
-          error.stack &&
-          error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
-      ) {
-        var stacks = [];
-        for (var o = observable; !!o; o = o.source) {
-          if (o.stack) {
-            stacks.unshift(o.stack);
-          }
+    // If possible, transform the error stack trace by removing Node and RxJS
+    // cruft, then concatenating with the stack trace of `observable`.
+    if (hasStacks &&
+        observable.stack &&
+        typeof error === 'object' &&
+        error !== null &&
+        error.stack &&
+        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
+    ) {
+      var stacks = [];
+      for (var o = observable; !!o; o = o.source) {
+        if (o.stack) {
+          stacks.unshift(o.stack);
         }
-        stacks.unshift(error.stack);
+      }
+      stacks.unshift(error.stack);
 
-        var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
-        error.stack = filterStackString(concatedStacks);
+      var concatedStacks = stacks.join('\n' + STACK_JUMP_SEPARATOR + '\n');
+      error.stack = filterStackString(concatedStacks);
     }
   }
 
   function filterStackString(stackString) {
-    var lines = stackString.split("\n"),
-        desiredLines = [];
+    var lines = stackString.split('\n'), desiredLines = [];
     for (var i = 0, len = lines.length; i < len; i++) {
       var line = lines[i];
 
@@ -111,7 +116,7 @@
         desiredLines.push(line);
       }
     }
-    return desiredLines.join("\n");
+    return desiredLines.join('\n');
   }
 
   function isInternalFrame(stackLine) {
@@ -127,8 +132,8 @@
   }
 
   function isNodeFrame(stackLine) {
-    return stackLine.indexOf("(module.js:") !== -1 ||
-      stackLine.indexOf("(node.js:") !== -1;
+    return stackLine.indexOf('(module.js:') !== -1 ||
+      stackLine.indexOf('(node.js:') !== -1;
   }
 
   function captureLine() {
@@ -137,8 +142,8 @@
     try {
       throw new Error();
     } catch (e) {
-      var lines = e.stack.split("\n");
-      var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
+      var lines = e.stack.split('\n');
+      var firstLine = lines[0].indexOf('@') > 0 ? lines[1] : lines[2];
       var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
       if (!fileNameAndLineNumber) { return; }
 
@@ -148,45 +153,50 @@
   }
 
   function getFileNameAndLineNumber(stackLine) {
-    // Named functions: "at functionName (filename:lineNumber:columnNumber)"
+    // Named functions: 'at functionName (filename:lineNumber:columnNumber)'
     var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
     if (attempt1) { return [attempt1[1], Number(attempt1[2])]; }
 
-    // Anonymous functions: "at filename:lineNumber:columnNumber"
+    // Anonymous functions: 'at filename:lineNumber:columnNumber'
     var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
     if (attempt2) { return [attempt2[1], Number(attempt2[2])]; }
 
-    // Firefox style: "function@filename:lineNumber or @filename:lineNumber"
+    // Firefox style: 'function@filename:lineNumber or @filename:lineNumber'
     var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
     if (attempt3) { return [attempt3[1], Number(attempt3[2])]; }
   }
 
   var EmptyError = Rx.EmptyError = function() {
     this.message = 'Sequence contains no elements.';
+    this.name = 'EmptyError';
     Error.call(this);
   };
   EmptyError.prototype = Error.prototype;
 
   var ObjectDisposedError = Rx.ObjectDisposedError = function() {
     this.message = 'Object has been disposed';
+    this.name = 'ObjectDisposedError';
     Error.call(this);
   };
   ObjectDisposedError.prototype = Error.prototype;
 
   var ArgumentOutOfRangeError = Rx.ArgumentOutOfRangeError = function () {
     this.message = 'Argument out of range';
+    this.name = 'ArgumentOutOfRangeError';
     Error.call(this);
   };
   ArgumentOutOfRangeError.prototype = Error.prototype;
 
   var NotSupportedError = Rx.NotSupportedError = function (message) {
     this.message = message || 'This operation is not supported';
+    this.name = 'NotSupportedError';
     Error.call(this);
   };
   NotSupportedError.prototype = Error.prototype;
 
   var NotImplementedError = Rx.NotImplementedError = function (message) {
     this.message = message || 'This operation is not implemented';
+    this.name = 'NotImplementedError';
     Error.call(this);
   };
   NotImplementedError.prototype = Error.prototype;
@@ -530,29 +540,10 @@
     return result;
   }
 
-  var errorObj = {e: {}};
-  var tryCatchTarget;
-  function tryCatcher() {
-    try {
-      return tryCatchTarget.apply(this, arguments);
-    } catch (e) {
-      errorObj.e = e;
-      return errorObj;
-    }
-  }
-  function tryCatch(fn) {
-    if (!isFunction(fn)) { throw new TypeError('fn must be a function'); }
-    tryCatchTarget = fn;
-    return tryCatcher;
-  }
-  function thrower(e) {
-    throw e;
-  }
-
   var hasProp = {}.hasOwnProperty,
       slice = Array.prototype.slice;
 
-  var inherits = this.inherits = Rx.internals.inherits = function (child, parent) {
+  var inherits = Rx.internals.inherits = function (child, parent) {
     function __() { this.constructor = child; }
     __.prototype = parent.prototype;
     child.prototype = new __();
@@ -772,92 +763,6 @@
     }());
   }
 
-  // Collections
-  function IndexedItem(id, value) {
-    this.id = id;
-    this.value = value;
-  }
-
-  IndexedItem.prototype.compareTo = function (other) {
-    var c = this.value.compareTo(other.value);
-    c === 0 && (c = this.id - other.id);
-    return c;
-  };
-
-  // Priority Queue for Scheduling
-  var PriorityQueue = Rx.internals.PriorityQueue = function (capacity) {
-    this.items = new Array(capacity);
-    this.length = 0;
-  };
-
-  var priorityProto = PriorityQueue.prototype;
-  priorityProto.isHigherPriority = function (left, right) {
-    return this.items[left].compareTo(this.items[right]) < 0;
-  };
-
-  priorityProto.percolate = function (index) {
-    if (index >= this.length || index < 0) { return; }
-    var parent = index - 1 >> 1;
-    if (parent < 0 || parent === index) { return; }
-    if (this.isHigherPriority(index, parent)) {
-      var temp = this.items[index];
-      this.items[index] = this.items[parent];
-      this.items[parent] = temp;
-      this.percolate(parent);
-    }
-  };
-
-  priorityProto.heapify = function (index) {
-    +index || (index = 0);
-    if (index >= this.length || index < 0) { return; }
-    var left = 2 * index + 1,
-        right = 2 * index + 2,
-        first = index;
-    if (left < this.length && this.isHigherPriority(left, first)) {
-      first = left;
-    }
-    if (right < this.length && this.isHigherPriority(right, first)) {
-      first = right;
-    }
-    if (first !== index) {
-      var temp = this.items[index];
-      this.items[index] = this.items[first];
-      this.items[first] = temp;
-      this.heapify(first);
-    }
-  };
-
-  priorityProto.peek = function () { return this.items[0].value; };
-
-  priorityProto.removeAt = function (index) {
-    this.items[index] = this.items[--this.length];
-    this.items[this.length] = undefined;
-    this.heapify();
-  };
-
-  priorityProto.dequeue = function () {
-    var result = this.peek();
-    this.removeAt(0);
-    return result;
-  };
-
-  priorityProto.enqueue = function (item) {
-    var index = this.length++;
-    this.items[index] = new IndexedItem(PriorityQueue.count++, item);
-    this.percolate(index);
-  };
-
-  priorityProto.remove = function (item) {
-    for (var i = 0; i < this.length; i++) {
-      if (this.items[i].value === item) {
-        this.removeAt(i);
-        return true;
-      }
-    }
-    return false;
-  };
-  PriorityQueue.count = 0;
-
   /**
    * Represents a group of disposable resources that are disposed together.
    * @constructor
@@ -1210,52 +1115,62 @@
 
     function invokeRecImmediate(scheduler, pair) {
       var state = pair[0], action = pair[1], group = new CompositeDisposable();
+      action(state, innerAction);
+      return group;
 
-      function recursiveAction(state1) {
-        action(state1, function (state2) {
-          var isAdded = false, isDone = false,
-          d = scheduler.scheduleWithState(state2, function (scheduler1, state3) {
-            if (isAdded) {
-              group.remove(d);
-            } else {
-              isDone = true;
-            }
-            recursiveAction(state3);
-            return disposableEmpty;
-          });
-          if (!isDone) {
-            group.add(d);
-            isAdded = true;
+      function innerAction(state2) {
+        var isAdded = false, isDone = false;
+
+        var d = scheduler.scheduleWithState(state2, scheduleWork);
+        if (!isDone) {
+          group.add(d);
+          isAdded = true;
+        }
+
+        function scheduleWork(_, state3) {
+          if (isAdded) {
+            group.remove(d);
+          } else {
+            isDone = true;
           }
-        });
+          action(state3, innerAction);
+          return disposableEmpty;
+        }
       }
-
-      recursiveAction(state);
-      return group;
     }
 
     function invokeRecDate(scheduler, pair, method) {
       var state = pair[0], action = pair[1], group = new CompositeDisposable();
-      function recursiveAction(state1) {
-        action(state1, function (state2, dueTime1) {
-          var isAdded = false, isDone = false,
-          d = scheduler[method](state2, dueTime1, function (scheduler1, state3) {
-            if (isAdded) {
-              group.remove(d);
-            } else {
-              isDone = true;
-            }
-            recursiveAction(state3);
-            return disposableEmpty;
-          });
-          if (!isDone) {
-            group.add(d);
-            isAdded = true;
-          }
-        });
-      };
-      recursiveAction(state);
+      action(state, innerAction);
       return group;
+
+      function innerAction(state2, dueTime1) {
+        var isAdded = false, isDone = false;
+
+        var d = scheduler[method](state2, dueTime1, scheduleWork);
+        if (!isDone) {
+          group.add(d);
+          isAdded = true;
+        }
+
+        function scheduleWork(_, state3) {
+          if (isAdded) {
+            group.remove(d);
+          } else {
+            isDone = true;
+          }
+          action(state3, innerAction);
+          return disposableEmpty;
+        }
+      }
+    }
+
+    function invokeRecDateRelative(s, p) {
+      return invokeRecDate(s, p, 'scheduleWithRelativeAndState');
+    }
+
+    function invokeRecDateAbsolute(s, p) {
+      return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState');
     }
 
     function scheduleInnerRecursive(action, self) {
@@ -1268,8 +1183,7 @@
      * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
      */
     schedulerProto.scheduleRecursive = function (action) {
-      return this.scheduleRecursiveWithState(action, function (_action, self) {
-        _action(function () { self(_action); }); });
+      return this.scheduleRecursiveWithState(action, scheduleInnerRecursive);
     };
 
     /**
@@ -1300,9 +1214,7 @@
      * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
      */
     schedulerProto.scheduleRecursiveWithRelativeAndState = function (state, dueTime, action) {
-      return this._scheduleRelative([state, action], dueTime, function (s, p) {
-        return invokeRecDate(s, p, 'scheduleWithRelativeAndState');
-      });
+      return this._scheduleRelative([state, action], dueTime, invokeRecDateRelative);
     };
 
     /**
@@ -1323,9 +1235,7 @@
      * @returns {Disposable} The disposable object used to cancel the scheduled action (best effort).
      */
     schedulerProto.scheduleRecursiveWithAbsoluteAndState = function (state, dueTime, action) {
-      return this._scheduleAbsolute([state, action], dueTime, function (s, p) {
-        return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState');
-      });
+      return this._scheduleAbsolute([state, action], dueTime, invokeRecDateAbsolute);
     };
   }(Scheduler.prototype));
 
@@ -1371,7 +1281,7 @@
 
     function runTrampoline () {
       while (queue.length > 0) {
-        var item = queue.dequeue();
+        var item = queue.shift();
         !item.isCancelled() && item.invoke();
       }
     }
@@ -1380,14 +1290,13 @@
       var si = new ScheduledItem(this, state, action, this.now());
 
       if (!queue) {
-        queue = new PriorityQueue(4);
-        queue.enqueue(si);
+        queue = [si];
 
         var result = tryCatch(runTrampoline)();
         queue = null;
         if (result === errorObj) { return thrower(result.e); }
       } else {
-        queue.enqueue(si);
+        queue.push(si);
       }
       return si.disposable;
     }
@@ -1703,188 +1612,6 @@
     };
   }());
 
-  var Enumerator = Rx.internals.Enumerator = function (next) {
-    this._next = next;
-  };
-
-  Enumerator.prototype.next = function () {
-    return this._next();
-  };
-
-  Enumerator.prototype[$iterator$] = function () { return this; }
-
-  var Enumerable = Rx.internals.Enumerable = function (iterator) {
-    this._iterator = iterator;
-  };
-
-  Enumerable.prototype[$iterator$] = function () {
-    return this._iterator();
-  };
-
-  Enumerable.prototype.concat = function () {
-    var sources = this;
-    return new AnonymousObservable(function (o) {
-      var e = sources[$iterator$]();
-
-      var isDisposed, subscription = new SerialDisposable();
-      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
-        if (isDisposed) { return; }
-        try {
-          var currentItem = e.next();
-        } catch (ex) {
-          return o.onError(ex);
-        }
-
-        if (currentItem.done) {
-          return o.onCompleted();
-        }
-
-        // Check if promise
-        var currentValue = currentItem.value;
-        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
-
-        var d = new SingleAssignmentDisposable();
-        subscription.setDisposable(d);
-        d.setDisposable(currentValue.subscribe(
-          function(x) { o.onNext(x); },
-          function(err) { o.onError(err); },
-          self)
-        );
-      });
-
-      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
-        isDisposed = true;
-      }));
-    });
-  };
-
-  Enumerable.prototype.catchError = function () {
-    var sources = this;
-    return new AnonymousObservable(function (o) {
-      var e = sources[$iterator$]();
-
-      var isDisposed, subscription = new SerialDisposable();
-      var cancelable = immediateScheduler.scheduleRecursiveWithState(null, function (lastException, self) {
-        if (isDisposed) { return; }
-
-        try {
-          var currentItem = e.next();
-        } catch (ex) {
-          return observer.onError(ex);
-        }
-
-        if (currentItem.done) {
-          if (lastException !== null) {
-            o.onError(lastException);
-          } else {
-            o.onCompleted();
-          }
-          return;
-        }
-
-        // Check if promise
-        var currentValue = currentItem.value;
-        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
-
-        var d = new SingleAssignmentDisposable();
-        subscription.setDisposable(d);
-        d.setDisposable(currentValue.subscribe(
-          function(x) { o.onNext(x); },
-          self,
-          function() { o.onCompleted(); }));
-      });
-      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
-        isDisposed = true;
-      }));
-    });
-  };
-
-
-  Enumerable.prototype.catchErrorWhen = function (notificationHandler) {
-    var sources = this;
-    return new AnonymousObservable(function (o) {
-      var exceptions = new Subject(),
-        notifier = new Subject(),
-        handled = notificationHandler(exceptions),
-        notificationDisposable = handled.subscribe(notifier);
-
-      var e = sources[$iterator$]();
-
-      var isDisposed,
-        lastException,
-        subscription = new SerialDisposable();
-      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
-        if (isDisposed) { return; }
-
-        try {
-          var currentItem = e.next();
-        } catch (ex) {
-          return o.onError(ex);
-        }
-
-        if (currentItem.done) {
-          if (lastException) {
-            o.onError(lastException);
-          } else {
-            o.onCompleted();
-          }
-          return;
-        }
-
-        // Check if promise
-        var currentValue = currentItem.value;
-        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
-
-        var outer = new SingleAssignmentDisposable();
-        var inner = new SingleAssignmentDisposable();
-        subscription.setDisposable(new CompositeDisposable(inner, outer));
-        outer.setDisposable(currentValue.subscribe(
-          function(x) { o.onNext(x); },
-          function (exn) {
-            inner.setDisposable(notifier.subscribe(self, function(ex) {
-              o.onError(ex);
-            }, function() {
-              o.onCompleted();
-            }));
-
-            exceptions.onNext(exn);
-          },
-          function() { o.onCompleted(); }));
-      });
-
-      return new CompositeDisposable(notificationDisposable, subscription, cancelable, disposableCreate(function () {
-        isDisposed = true;
-      }));
-    });
-  };
-
-  var enumerableRepeat = Enumerable.repeat = function (value, repeatCount) {
-    if (repeatCount == null) { repeatCount = -1; }
-    return new Enumerable(function () {
-      var left = repeatCount;
-      return new Enumerator(function () {
-        if (left === 0) { return doneEnumerator; }
-        if (left > 0) { left--; }
-        return { done: false, value: value };
-      });
-    });
-  };
-
-  var enumerableOf = Enumerable.of = function (source, selector, thisArg) {
-    if (selector) {
-      var selectorFn = bindCallback(selector, thisArg, 3);
-    }
-    return new Enumerable(function () {
-      var index = -1;
-      return new Enumerator(
-        function () {
-          return ++index < source.length ?
-            { done: false, value: !selector ? source[index] : selectorFn(source[index], index, source) } :
-            doneEnumerator;
-        });
-    });
-  };
-
   /**
    * Supports push-style iteration over an observable sequence.
    */
@@ -1916,7 +1643,6 @@
      */
     function AbstractObserver() {
       this.isStopped = false;
-      __super__.call(this);
     }
 
     // Must be implemented by other observers
@@ -1929,7 +1655,7 @@
      * @param {Any} value Next element in the sequence.
      */
     AbstractObserver.prototype.onNext = function (value) {
-      if (!this.isStopped) { this.next(value); }
+      !this.isStopped && this.next(value);
     };
 
     /**
@@ -1956,9 +1682,7 @@
     /**
      * Disposes the observer, causing it to transition to the stopped state.
      */
-    AbstractObserver.prototype.dispose = function () {
-      this.isStopped = true;
-    };
+    AbstractObserver.prototype.dispose = function () { this.isStopped = true; };
 
     AbstractObserver.prototype.fail = function (e) {
       if (!this.isStopped) {
@@ -2025,25 +1749,23 @@
    */
   var Observable = Rx.Observable = (function () {
 
-    function Observable(subscribe) {
-      if (Rx.config.longStackSupport && hasStacks) {
-        try {
-          throw new Error();
-        } catch (e) {
-          this.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
-        }
-
-        var self = this;
-        this._subscribe = function (observer) {
-          var oldOnError = observer.onError.bind(observer);
+    function makeSubscribe(self, subscribe) {
+      return function (o) {
+        var oldOnError = o.onError;
+        o.onError = function (e) {
+          makeStackTraceLong(e, self);
+          oldOnError.call(o, e);
+        };
 
-          observer.onError = function (err) {
-            makeStackTraceLong(err, self);
-            oldOnError(err);
-          };
+        return subscribe.call(self, o);
+      };
+    }
 
-          return subscribe.call(self, observer);
-        };
+    function Observable(subscribe) {
+      if (Rx.config.longStackSupport && hasStacks) {
+        var e = tryCatch(thrower)(new Error()).e;
+        this.stack = e.stack.substring(e.stack.indexOf('\n') + 1);
+        this._subscribe = makeSubscribe(this, subscribe);
       } else {
         this._subscribe = subscribe;
       }
@@ -2052,16 +1774,25 @@
     observableProto = Observable.prototype;
 
     /**
-     *  Subscribes an observer to the observable sequence.
-     *  @param {Mixed} [observerOrOnNext] The object that is to receive notifications or an action to invoke for each element in the observable sequence.
+    * Determines whether the given object is an Observable
+    * @param {Any} An object to determine whether it is an Observable
+    * @returns {Boolean} true if an Observable, else false.
+    */
+    Observable.isObservable = function (o) {
+      return o && isFunction(o.subscribe);
+    }
+
+    /**
+     *  Subscribes an o to the observable sequence.
+     *  @param {Mixed} [oOrOnNext] The object that is to receive notifications or an action to invoke for each element in the observable sequence.
      *  @param {Function} [onError] Action to invoke upon exceptional termination of the observable sequence.
      *  @param {Function} [onCompleted] Action to invoke upon graceful termination of the observable sequence.
      *  @returns {Diposable} A disposable handling the subscriptions and unsubscriptions.
      */
-    observableProto.subscribe = observableProto.forEach = function (observerOrOnNext, onError, onCompleted) {
-      return this._subscribe(typeof observerOrOnNext === 'object' ?
-        observerOrOnNext :
-        observerCreate(observerOrOnNext, onError, onCompleted));
+    observableProto.subscribe = observableProto.forEach = function (oOrOnNext, onError, onCompleted) {
+      return this._subscribe(typeof oOrOnNext === 'object' ?
+        oOrOnNext :
+        observerCreate(oOrOnNext, onError, onCompleted));
     };
 
     /**
@@ -2135,6 +1866,294 @@
     return ObservableBase;
   }(Observable));
 
+var FlatMapObservable = (function(__super__){
+
+    inherits(FlatMapObservable, __super__);
+
+    function FlatMapObservable(source, selector, resultSelector, thisArg) {
+        this.resultSelector = Rx.helpers.isFunction(resultSelector) ?
+            resultSelector : null;
+
+        this.selector = Rx.internals.bindCallback(Rx.helpers.isFunction(selector) ? selector : function() { return selector; }, thisArg, 3);
+        this.source = source;
+
+        __super__.call(this);
+
+    }
+
+    FlatMapObservable.prototype.subscribeCore = function(o) {
+        return this.source.subscribe(new InnerObserver(o, this.selector, this.resultSelector, this));
+    };
+
+    function InnerObserver(observer, selector, resultSelector, source) {
+        this.i = 0;
+        this.selector = selector;
+        this.resultSelector = resultSelector;
+        this.source = source;
+        this.isStopped = false;
+        this.o = observer;
+    }
+
+    InnerObserver.prototype._wrapResult = function(result, x, i) {
+        return this.resultSelector ?
+            result.map(function(y, i2) { return this.resultSelector(x, y, i, i2); }, this) :
+            result;
+    };
+
+    InnerObserver.prototype.onNext = function(x) {
+
+        if (this.isStopped) return;
+
+        var i = this.i++;
+        var result = tryCatch(this.selector)(x, i, this.source);
+
+        if (result === errorObj) {
+            return this.o.onError(result.e);
+        }
+
+        Rx.helpers.isPromise(result) && (result = Rx.Observable.fromPromise(result));
+        (Rx.helpers.isArrayLike(result) || Rx.helpers.isIterable(result)) && (result = Rx.Observable.from(result));
+
+        this.o.onNext(this._wrapResult(result, x, i));
+
+    };
+
+    InnerObserver.prototype.onError = function(e) {
+        if(!this.isStopped) { this.isStopped = true; this.o.onError(e); }
+    };
+
+    InnerObserver.prototype.onCompleted = function() {
+        if (!this.isStopped) {this.isStopped = true; this.o.onCompleted(); }
+    };
+
+    return FlatMapObservable;
+
+}(ObservableBase));
+
+  var Enumerable = Rx.internals.Enumerable = function () { };
+
+  var ConcatEnumerableObservable = (function(__super__) {
+    inherits(ConcatEnumerableObservable, __super__);
+    function ConcatEnumerableObservable(sources) {
+      this.sources = sources;
+      __super__.call(this);
+    }
+    
+    ConcatEnumerableObservable.prototype.subscribeCore = function (o) {
+      var isDisposed, subscription = new SerialDisposable();
+      var cancelable = immediateScheduler.scheduleRecursiveWithState(this.sources[$iterator$](), function (e, self) {
+        if (isDisposed) { return; }
+        var currentItem = tryCatch(e.next).call(e);
+        if (currentItem === errorObj) { return o.onError(currentItem.e); }
+
+        if (currentItem.done) {
+          return o.onCompleted();
+        }
+
+        // Check if promise
+        var currentValue = currentItem.value;
+        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
+
+        var d = new SingleAssignmentDisposable();
+        subscription.setDisposable(d);
+        d.setDisposable(currentValue.subscribe(new InnerObserver(o, self, e)));
+      });
+
+      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+        isDisposed = true;
+      }));
+    };
+    
+    function InnerObserver(o, s, e) {
+      this.o = o;
+      this.s = s;
+      this.e = e;
+      this.isStopped = false;
+    }
+    InnerObserver.prototype.onNext = function (x) { if(!this.isStopped) { this.o.onNext(x); } };
+    InnerObserver.prototype.onError = function (err) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(err);
+      }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.s(this.e);
+      }
+    };
+    InnerObserver.prototype.dispose = function () { this.isStopped = true; };
+    InnerObserver.prototype.fail = function (err) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(err);
+        return true;
+      }
+      return false;
+    };
+    
+    return ConcatEnumerableObservable;
+  }(ObservableBase));
+
+  Enumerable.prototype.concat = function () {
+    return new ConcatEnumerableObservable(this);
+  };
+  
+  var CatchErrorObservable = (function(__super__) {
+    inherits(CatchErrorObservable, __super__);
+    function CatchErrorObservable(sources) {
+      this.sources = sources;
+      __super__.call(this);
+    }
+    
+    CatchErrorObservable.prototype.subscribeCore = function (o) {
+      var e = this.sources[$iterator$]();
+
+      var isDisposed, subscription = new SerialDisposable();
+      var cancelable = immediateScheduler.scheduleRecursiveWithState(null, function (lastException, self) {
+        if (isDisposed) { return; }
+        var currentItem = tryCatch(e.next).call(e);
+        if (currentItem === errorObj) { return o.onError(currentItem.e); }
+
+        if (currentItem.done) {
+          return lastException !== null ? o.onError(lastException) : o.onCompleted();
+        }
+
+        // Check if promise
+        var currentValue = currentItem.value;
+        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
+
+        var d = new SingleAssignmentDisposable();
+        subscription.setDisposable(d);
+        d.setDisposable(currentValue.subscribe(
+          function(x) { o.onNext(x); },
+          self,
+          function() { o.onCompleted(); }));
+      });
+      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+        isDisposed = true;
+      }));
+    };
+    
+    return CatchErrorObservable;
+  }(ObservableBase));
+
+  Enumerable.prototype.catchError = function () {
+    return new CatchErrorObservable(this);
+  };
+
+  Enumerable.prototype.catchErrorWhen = function (notificationHandler) {
+    var sources = this;
+    return new AnonymousObservable(function (o) {
+      var exceptions = new Subject(),
+        notifier = new Subject(),
+        handled = notificationHandler(exceptions),
+        notificationDisposable = handled.subscribe(notifier);
+
+      var e = sources[$iterator$]();
+
+      var isDisposed,
+        lastException,
+        subscription = new SerialDisposable();
+      var cancelable = immediateScheduler.scheduleRecursive(function (self) {
+        if (isDisposed) { return; }
+        var currentItem = tryCatch(e.next).call(e);
+        if (currentItem === errorObj) { return o.onError(currentItem.e); }
+
+        if (currentItem.done) {
+          if (lastException) {
+            o.onError(lastException);
+          } else {
+            o.onCompleted();
+          }
+          return;
+        }
+
+        // Check if promise
+        var currentValue = currentItem.value;
+        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
+
+        var outer = new SingleAssignmentDisposable();
+        var inner = new SingleAssignmentDisposable();
+        subscription.setDisposable(new CompositeDisposable(inner, outer));
+        outer.setDisposable(currentValue.subscribe(
+          function(x) { o.onNext(x); },
+          function (exn) {
+            inner.setDisposable(notifier.subscribe(self, function(ex) {
+              o.onError(ex);
+            }, function() {
+              o.onCompleted();
+            }));
+
+            exceptions.onNext(exn);
+          },
+          function() { o.onCompleted(); }));
+      });
+
+      return new CompositeDisposable(notificationDisposable, subscription, cancelable, disposableCreate(function () {
+        isDisposed = true;
+      }));
+    });
+  };
+  
+  var RepeatEnumerable = (function (__super__) {
+    inherits(RepeatEnumerable, __super__);
+    
+    function RepeatEnumerable(v, c) {
+      this.v = v;
+      this.c = c == null ? -1 : c;
+    }
+    RepeatEnumerable.prototype[$iterator$] = function () {
+      return new RepeatEnumerator(this); 
+    };
+    
+    function RepeatEnumerator(p) {
+      this.v = p.v;
+      this.l = p.c;
+    }
+    RepeatEnumerator.prototype.next = function () {
+      if (this.l === 0) { return doneEnumerator; }
+      if (this.l > 0) { this.l--; }
+      return { done: false, value: this.v }; 
+    };
+    
+    return RepeatEnumerable;
+  }(Enumerable));
+
+  var enumerableRepeat = Enumerable.repeat = function (value, repeatCount) {
+    return new RepeatEnumerable(value, repeatCount);
+  };
+  
+  var OfEnumerable = (function(__super__) {
+    inherits(OfEnumerable, __super__);
+    function OfEnumerable(s, fn, thisArg) {
+      this.s = s;
+      this.fn = fn ? bindCallback(fn, thisArg, 3) : null;
+    }
+    OfEnumerable.prototype[$iterator$] = function () {
+      return new OfEnumerator(this);
+    };
+    
+    function OfEnumerator(p) {
+      this.i = -1;
+      this.s = p.s;
+      this.l = this.s.length;
+      this.fn = p.fn;
+    }
+    OfEnumerator.prototype.next = function () {
+     return ++this.i < this.l ?
+       { done: false, value: !this.fn ? this.s[this.i] : this.fn(this.s[this.i], this.i, this.s) } :
+       doneEnumerator; 
+    };
+    
+    return OfEnumerable;
+  }(Enumerable));
+
+  var enumerableOf = Enumerable.of = function (source, selector, thisArg) {
+    return new OfEnumerable(source, selector, thisArg);
+  };
+
   var ScheduledObserver = Rx.internals.ScheduledObserver = (function (__super__) {
     inherits(ScheduledObserver, __super__);
 
@@ -2164,13 +2183,13 @@
     };
 
     ScheduledObserver.prototype.ensureActive = function () {
-      var isOwner = false, parent = this;
+      var isOwner = false;
       if (!this.hasFaulted && this.queue.length > 0) {
         isOwner = !this.isAcquired;
         this.isAcquired = true;
       }
       if (isOwner) {
-        this.disposable.setDisposable(this.scheduler.scheduleRecursive(function (self) {
+        this.disposable.setDisposable(this.scheduler.scheduleRecursiveWithState(this, function (parent, self) {
           var work;
           if (parent.queue.length > 0) {
             work = parent.queue.shift();
@@ -2178,14 +2197,13 @@
             parent.isAcquired = false;
             return;
           }
-          try {
-            work();
-          } catch (ex) {
+          var res = tryCatch(work)();
+          if (res === errorObj) {
             parent.queue = [];
             parent.hasFaulted = true;
-            throw ex;
+            return thrower(res.e);
           }
-          self();
+          self(parent);
         }));
       }
     };
@@ -2205,42 +2223,42 @@
       __super__.call(this);
     }
 
-    ToArrayObservable.prototype.subscribeCore = function(observer) {
-      return this.source.subscribe(new ToArrayObserver(observer));
+    ToArrayObservable.prototype.subscribeCore = function(o) {
+      return this.source.subscribe(new InnerObserver(o));
     };
 
-    return ToArrayObservable;
-  }(ObservableBase));
-
-  function ToArrayObserver(observer) {
-    this.observer = observer;
-    this.a = [];
-    this.isStopped = false;
-  }
-  ToArrayObserver.prototype.onNext = function (x) { if(!this.isStopped) { this.a.push(x); } };
-  ToArrayObserver.prototype.onError = function (e) {
-    if (!this.isStopped) {
-      this.isStopped = true;
-      this.observer.onError(e);
-    }
-  };
-  ToArrayObserver.prototype.onCompleted = function () {
-    if (!this.isStopped) {
-      this.isStopped = true;
-      this.observer.onNext(this.a);
-      this.observer.onCompleted();
-    }
-  };
-  ToArrayObserver.prototype.dispose = function () { this.isStopped = true; }
-  ToArrayObserver.prototype.fail = function (e) {
-    if (!this.isStopped) {
-      this.isStopped = true;
-      this.observer.onError(e);
-      return true;
+    function InnerObserver(o) {
+      this.o = o;
+      this.a = [];
+      this.isStopped = false;
     }
+    InnerObserver.prototype.onNext = function (x) { if(!this.isStopped) { this.a.push(x); } };
+    InnerObserver.prototype.onError = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+      }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onNext(this.a);
+        this.o.onCompleted();
+      }
+    };
+    InnerObserver.prototype.dispose = function () { this.isStopped = true; }
+    InnerObserver.prototype.fail = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+ 
+      return false;
+    };
 
-    return false;
-  };
+    return ToArrayObservable;
+  }(ObservableBase));
 
   /**
   * Creates an array from an observable sequence.
@@ -2259,7 +2277,7 @@
    * @param {Function} subscribe Implementation of the resulting observable sequence's subscribe method, returning a function that will be wrapped in a Disposable.
    * @returns {Observable} The observable sequence with the specified implementation for the Subscribe method.
    */
-  Observable.create = Observable.createWithDisposable = function (subscribe, parent) {
+  Observable.create = function (subscribe, parent) {
     return new AnonymousObservable(subscribe, parent);
   };
 
@@ -2292,26 +2310,29 @@
     }
 
     EmptyObservable.prototype.subscribeCore = function (observer) {
-      var sink = new EmptySink(observer, this);
+      var sink = new EmptySink(observer, this.scheduler);
       return sink.run();
     };
 
-    function EmptySink(observer, parent) {
+    function EmptySink(observer, scheduler) {
       this.observer = observer;
-      this.parent = parent;
+      this.scheduler = scheduler;
     }
 
     function scheduleItem(s, state) {
       state.onCompleted();
+      return disposableEmpty;
     }
 
     EmptySink.prototype.run = function () {
-      return this.parent.scheduler.scheduleWithState(this.observer, scheduleItem);
+      return this.scheduler.scheduleWithState(this.observer, scheduleItem);
     };
 
     return EmptyObservable;
   }(ObservableBase));
 
+  var EMPTY_OBSERVABLE = new EmptyObservable(immediateScheduler);
+
   /**
    *  Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message.
    *
@@ -2323,7 +2344,7 @@
    */
   var observableEmpty = Observable.empty = function (scheduler) {
     isScheduler(scheduler) || (scheduler = immediateScheduler);
-    return new EmptyObservable(scheduler);
+    return scheduler === immediateScheduler ? EMPTY_OBSERVABLE : new EmptyObservable(scheduler);
   };
 
   var FromObservable = (function(__super__) {
@@ -2335,8 +2356,8 @@
       __super__.call(this);
     }
 
-    FromObservable.prototype.subscribeCore = function (observer) {
-      var sink = new FromSink(observer, this);
+    FromObservable.prototype.subscribeCore = function (o) {
+      var sink = new FromSink(o, this);
       return sink.run();
     };
 
@@ -2344,38 +2365,30 @@
   }(ObservableBase));
 
   var FromSink = (function () {
-    function FromSink(observer, parent) {
-      this.observer = observer;
+    function FromSink(o, parent) {
+      this.o = o;
       this.parent = parent;
     }
 
     FromSink.prototype.run = function () {
       var list = Object(this.parent.iterable),
           it = getIterable(list),
-          observer = this.observer,
+          o = this.o,
           mapper = this.parent.mapper;
 
       function loopRecursive(i, recurse) {
-        try {
-          var next = it.next();
-        } catch (e) {
-          return observer.onError(e);
-        }
-        if (next.done) {
-          return observer.onCompleted();
-        }
+        var next = tryCatch(it.next).call(it);
+        if (next === errorObj) { return o.onError(next.e); }
+        if (next.done) { return o.onCompleted(); }
 
         var result = next.value;
 
-        if (mapper) {
-          try {
-            result = mapper(result, i);
-          } catch (e) {
-            return observer.onError(e);
-          }
+        if (isFunction(mapper)) {
+          result = tryCatch(mapper)(result, i);
+          if (result === errorObj) { return o.onError(result.e); }
         }
 
-        observer.onNext(result);
+        o.onNext(result);
         recurse(i + 1);
       }
 
@@ -2387,7 +2400,7 @@
 
   var maxSafeInteger = Math.pow(2, 53) - 1;
 
-  function StringIterable(str) {
+  function StringIterable(s) {
     this._s = s;
   }
 
@@ -2395,7 +2408,7 @@
     return new StringIterator(this._s);
   };
 
-  function StringIterator(str) {
+  function StringIterator(s) {
     this._s = s;
     this._l = s.length;
     this._i = 0;
@@ -2550,12 +2563,14 @@
     return NeverObservable;
   }(ObservableBase));
 
+  var NEVER_OBSERVABLE = new NeverObservable();
+
   /**
    * Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins).
    * @returns {Observable} An observable sequence whose observers will never get called.
    */
   var observableNever = Observable.never = function () {
-    return new NeverObservable();
+    return NEVER_OBSERVABLE;
   };
 
   function observableOf (scheduler, array) {
@@ -2636,7 +2651,7 @@
     inherits(RangeObservable, __super__);
     function RangeObservable(start, count, scheduler) {
       this.start = start;
-      this.count = count;
+      this.rangeCount = count;
       this.scheduler = scheduler;
       __super__.call(this);
     }
@@ -2656,7 +2671,7 @@
     }
 
     RangeSink.prototype.run = function () {
-      var start = this.parent.start, count = this.parent.count, observer = this.observer;
+      var start = this.parent.start, count = this.parent.rangeCount, observer = this.observer;
       function loopRecursive(i, recurse) {
         if (i < count) {
           observer.onNext(start + i);
@@ -2741,23 +2756,28 @@
     }
 
     JustObservable.prototype.subscribeCore = function (observer) {
-      var sink = new JustSink(observer, this);
+      var sink = new JustSink(observer, this.value, this.scheduler);
       return sink.run();
     };
 
-    function JustSink(observer, parent) {
+    function JustSink(observer, value, scheduler) {
       this.observer = observer;
-      this.parent = parent;
+      this.value = value;
+      this.scheduler = scheduler;
     }
 
     function scheduleItem(s, state) {
       var value = state[0], observer = state[1];
       observer.onNext(value);
       observer.onCompleted();
+      return disposableEmpty;
     }
 
     JustSink.prototype.run = function () {
-      return this.parent.scheduler.scheduleWithState([this.parent.value, this.observer], scheduleItem);
+      var state = [this.value, this.observer];
+      return this.scheduler === immediateScheduler ?
+        scheduleItem(null, state) :
+        this.scheduler.scheduleWithState(state, scheduleItem);
     };
 
     return JustObservable;
@@ -2770,7 +2790,7 @@
    * @param {Scheduler} scheduler Scheduler to send the single element on. If not specified, defaults to Scheduler.immediate.
    * @returns {Observable} An observable sequence containing the single specified element.
    */
-  var observableReturn = Observable['return'] = Observable.just = Observable.returnValue = function (value, scheduler) {
+  var observableReturn = Observable['return'] = Observable.just = function (value, scheduler) {
     isScheduler(scheduler) || (scheduler = immediateScheduler);
     return new JustObservable(value, scheduler);
   };
@@ -2783,23 +2803,23 @@
       __super__.call(this);
     }
 
-    ThrowObservable.prototype.subscribeCore = function (observer) {
-      var sink = new ThrowSink(observer, this);
+    ThrowObservable.prototype.subscribeCore = function (o) {
+      var sink = new ThrowSink(o, this);
       return sink.run();
     };
 
-    function ThrowSink(observer, parent) {
-      this.observer = observer;
-      this.parent = parent;
+    function ThrowSink(o, p) {
+      this.o = o;
+      this.p = p;
     }
 
     function scheduleItem(s, state) {
-      var error = state[0], observer = state[1];
-      observer.onError(error);
+      var e = state[0], o = state[1];
+      o.onError(e);
     }
 
     ThrowSink.prototype.run = function () {
-      return this.parent.scheduler.scheduleWithState([this.parent.error, this.observer], scheduleItem);
+      return this.p.scheduler.scheduleWithState([this.p.error, this.o], scheduleItem);
     };
 
     return ThrowObservable;
@@ -2812,44 +2832,51 @@
    * @param {Scheduler} scheduler Scheduler to send the exceptional termination call on. If not specified, defaults to Scheduler.immediate.
    * @returns {Observable} The observable sequence that terminates exceptionally with the specified exception object.
    */
-  var observableThrow = Observable['throw'] = Observable.throwError = Observable.throwException = function (error, scheduler) {
+  var observableThrow = Observable['throw'] = function (error, scheduler) {
     isScheduler(scheduler) || (scheduler = immediateScheduler);
     return new ThrowObservable(error, scheduler);
   };
 
+  var CatchObserver = (function(__super__) {
+    inherits(CatchObserver, __super__);
+    function CatchObserver(o, s, fn) {
+      this._o = o;
+      this._s = s;
+      this._fn = fn;
+      __super__.call(this);
+    }
+
+    CatchObserver.prototype.next = function (x) { this._o.onNext(x); };
+    CatchObserver.prototype.completed = function () { return this._o.onCompleted(); };
+    CatchObserver.prototype.error = function (e) {
+      var result = tryCatch(this._fn)(e);
+      if (result === errorObj) { return this._o.onError(result.e); }
+      isPromise(result) && (result = observableFromPromise(result));
+
+      var d = new SingleAssignmentDisposable();
+      this._s.setDisposable(d);
+      d.setDisposable(result.subscribe(this._o));
+    };
+
+    return CatchObserver;
+  }(AbstractObserver));
+
   function observableCatchHandler(source, handler) {
     return new AnonymousObservable(function (o) {
       var d1 = new SingleAssignmentDisposable(), subscription = new SerialDisposable();
       subscription.setDisposable(d1);
-      d1.setDisposable(source.subscribe(function (x) { o.onNext(x); }, function (e) {
-        try {
-          var result = handler(e);
-        } catch (ex) {
-          return o.onError(ex);
-        }
-        isPromise(result) && (result = observableFromPromise(result));
-
-        var d = new SingleAssignmentDisposable();
-        subscription.setDisposable(d);
-        d.setDisposable(result.subscribe(o));
-      }, function (x) { o.onCompleted(x); }));
-
+      d1.setDisposable(source.subscribe(new CatchObserver(o, subscription, handler)));
       return subscription;
     }, source);
   }
 
   /**
    * Continues an observable sequence that is terminated by an exception with the next observable sequence.
-   * @example
-   * 1 - xs.catchException(ys)
-   * 2 - xs.catchException(function (ex) { return ys(ex); })
    * @param {Mixed} handlerOrSecond Exception handler function that returns an observable sequence given the error that occurred in the first sequence, or a second observable sequence used to produce results when an error occurred in the first sequence.
    * @returns {Observable} An observable sequence containing the first sequence's elements, followed by the elements of the handler sequence in case an exception occurred.
    */
-  observableProto['catch'] = observableProto.catchError = observableProto.catchException = function (handlerOrSecond) {
-    return typeof handlerOrSecond === 'function' ?
-      observableCatchHandler(this, handlerOrSecond) :
-      observableCatch([this, handlerOrSecond]);
+  observableProto['catch'] = function (handlerOrSecond) {
+    return isFunction(handlerOrSecond) ? observableCatchHandler(this, handlerOrSecond) : observableCatch([this, handlerOrSecond]);
   };
 
   /**
@@ -2857,12 +2884,14 @@
    * @param {Array | Arguments} args Arguments or an array to use as the next sequence if an error occurs.
    * @returns {Observable} An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully.
    */
-  var observableCatch = Observable.catchError = Observable['catch'] = Observable.catchException = function () {
-    var items = [];
+  var observableCatch = Observable['catch'] = function () {
+    var items;
     if (Array.isArray(arguments[0])) {
       items = arguments[0];
     } else {
-      for(var i = 0, len = arguments.length; i < len; i++) { items.push(arguments[i]); }
+      var len = arguments.length;
+      items = new Array(len);
+      for(var i = 0; i < len; i++) { items[i] = arguments[i]; }
     }
     return enumerableOf(items).catchError();
   };
@@ -2887,6 +2916,13 @@
     return combineLatest.apply(this, args);
   };
 
+  function falseFactory() { return false; }
+  function argumentsToArray() {
+    var len = arguments.length, args = new Array(len);
+    for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+    return args;
+  }
+
   /**
    * Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences or Promises produces an element.
    *
@@ -2898,12 +2934,11 @@
   var combineLatest = Observable.combineLatest = function () {
     var len = arguments.length, args = new Array(len);
     for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
-    var resultSelector = args.pop();
+    var resultSelector = isFunction(args[len - 1]) ? args.pop() : argumentsToArray;
     Array.isArray(args[0]) && (args = args[0]);
 
     return new AnonymousObservable(function (o) {
       var n = args.length,
-        falseFactory = function () { return false; },
         hasValue = arrayInitialize(n, falseFactory),
         hasValueAll = false,
         isDone = arrayInitialize(n, falseFactory),
@@ -2958,6 +2993,52 @@
     return observableConcat.apply(null, args);
   };
 
+  var ConcatObservable = (function(__super__) {
+    inherits(ConcatObservable, __super__);
+    function ConcatObservable(sources) {
+      this.sources = sources;
+      __super__.call(this);
+    }
+
+    ConcatObservable.prototype.subscribeCore = function(o) {
+      var sink = new ConcatSink(this.sources, o);
+      return sink.run();
+    };
+
+    function ConcatSink(sources, o) {
+      this.sources = sources;
+      this.o = o;
+    }
+    ConcatSink.prototype.run = function () {
+      var isDisposed, subscription = new SerialDisposable(), sources = this.sources, length = sources.length, o = this.o;
+      var cancelable = immediateScheduler.scheduleRecursiveWithState(0, function (i, self) {
+        if (isDisposed) { return; }
+        if (i === length) {
+          return o.onCompleted();
+        }
+
+        // Check if promise
+        var currentValue = sources[i];
+        isPromise(currentValue) && (currentValue = observableFromPromise(currentValue));
+
+        var d = new SingleAssignmentDisposable();
+        subscription.setDisposable(d);
+        d.setDisposable(currentValue.subscribe(
+          function (x) { o.onNext(x); },
+          function (e) { o.onError(e); },
+          function () { self(i + 1); }
+        ));
+      });
+
+      return new CompositeDisposable(subscription, cancelable, disposableCreate(function () {
+        isDisposed = true;
+      }));
+    };
+
+
+    return ConcatObservable;
+  }(ObservableBase));
+
   /**
    * Concatenates all the observable sequences.
    * @param {Array | Arguments} args Arguments or an array to concat to the observable sequence.
@@ -2971,14 +3052,14 @@
       args = new Array(arguments.length);
       for(var i = 0, len = arguments.length; i < len; i++) { args[i] = arguments[i]; }
     }
-    return enumerableOf(args).concat();
+    return new ConcatObservable(args);
   };
 
   /**
    * Concatenates an observable sequence of observable sequences.
    * @returns {Observable} An observable sequence that contains the elements of each observed inner sequence, in sequential order.
    */
-  observableProto.concatAll = observableProto.concatObservable = function () {
+  observableProto.concatAll = function () {
     return this.merge(1);
   };
 
@@ -3147,11 +3228,6 @@
       return g;
     };
 
-    return MergeAllObservable;
-  }(ObservableBase));
-
-  var MergeAllObserver = (function() {
-
     function MergeAllObserver(o, g) {
       this.o = o;
       this.g = g;
@@ -3165,7 +3241,7 @@
 
       isPromise(innerSource) && (innerSource = observableFromPromise(innerSource));
 
-      sad.setDisposable(innerSource.subscribe(new InnerObserver(this, this.g, sad)));
+      sad.setDisposable(innerSource.subscribe(new InnerObserver(this, sad)));
     };
     MergeAllObserver.prototype.onError = function (e) {
       if(!this.isStopped) {
@@ -3191,9 +3267,8 @@
       return false;
     };
 
-    function InnerObserver(parent, g, sad) {
+    function InnerObserver(parent, sad) {
       this.parent = parent;
-      this.g = g;
       this.sad = sad;
       this.isStopped = false;
     }
@@ -3223,15 +3298,14 @@
       return false;
     };
 
-    return MergeAllObserver;
-
-  }());
+    return MergeAllObservable;
+  }(ObservableBase));
 
   /**
   * Merges an observable sequence of observable sequences into an observable sequence.
   * @returns {Observable} The observable sequence that merges the elements of the inner sequences.
   */
-  observableProto.mergeAll = observableProto.mergeObservable = function () {
+  observableProto.mergeAll = function () {
     return new MergeAllObservable(this);
   };
 
@@ -3346,87 +3420,171 @@
     }, source);
   };
 
+  var SwitchObservable = (function(__super__) {
+    inherits(SwitchObservable, __super__);
+    function SwitchObservable(source) {
+      this.source = source;
+      __super__.call(this);
+    }
+
+    SwitchObservable.prototype.subscribeCore = function (o) {
+      var inner = new SerialDisposable(), s = this.source.subscribe(new SwitchObserver(o, inner));
+      return new CompositeDisposable(s, inner);
+    };
+
+    function SwitchObserver(o, inner) {
+      this.o = o;
+      this.inner = inner;
+      this.stopped = false;
+      this.latest = 0;
+      this.hasLatest = false;
+      this.isStopped = false;
+    }
+    SwitchObserver.prototype.onNext = function (innerSource) {
+      if (this.isStopped) { return; }
+      var d = new SingleAssignmentDisposable(), id = ++this.latest;
+      this.hasLatest = true;
+      this.inner.setDisposable(d);
+      isPromise(innerSource) && (innerSource = observableFromPromise(innerSource));
+      d.setDisposable(innerSource.subscribe(new InnerObserver(this, id)));
+    };
+    SwitchObserver.prototype.onError = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+      }
+    };
+    SwitchObserver.prototype.onCompleted = function () {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.stopped = true;
+        !this.hasLatest && this.o.onCompleted();
+      }
+    };
+    SwitchObserver.prototype.dispose = function () { this.isStopped = true; };
+    SwitchObserver.prototype.fail = function (e) {
+      if(!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+      return false;
+    };
+
+    function InnerObserver(parent, id) {
+      this.parent = parent;
+      this.id = id;
+      this.isStopped = false;
+    }
+    InnerObserver.prototype.onNext = function (x) {
+      if (this.isStopped) { return; }
+      this.parent.latest === this.id && this.parent.o.onNext(x);
+    };
+    InnerObserver.prototype.onError = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.parent.latest === this.id && this.parent.o.onError(e);
+      }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        if (this.parent.latest === this.id) {
+          this.parent.hasLatest = false;
+          this.parent.isStopped && this.parent.o.onCompleted();
+        }
+      }
+    };
+    InnerObserver.prototype.dispose = function () { this.isStopped = true; }
+    InnerObserver.prototype.fail = function (e) {
+      if(!this.isStopped) {
+        this.isStopped = true;
+        this.parent.o.onError(e);
+        return true;
+      }
+      return false;
+    };
+
+    return SwitchObservable;
+  }(ObservableBase));
+
   /**
-   * Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
-   * @returns {Observable} The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.
-   */
+  * Transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
+  * @returns {Observable} The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received.
+  */
   observableProto['switch'] = observableProto.switchLatest = function () {
-    var sources = this;
-    return new AnonymousObservable(function (observer) {
-      var hasLatest = false,
-        innerSubscription = new SerialDisposable(),
-        isStopped = false,
-        latest = 0,
-        subscription = sources.subscribe(
-          function (innerSource) {
-            var d = new SingleAssignmentDisposable(), id = ++latest;
-            hasLatest = true;
-            innerSubscription.setDisposable(d);
-
-            // Check if Promise or Observable
-            isPromise(innerSource) && (innerSource = observableFromPromise(innerSource));
-
-            d.setDisposable(innerSource.subscribe(
-              function (x) { latest === id && observer.onNext(x); },
-              function (e) { latest === id && observer.onError(e); },
-              function () {
-                if (latest === id) {
-                  hasLatest = false;
-                  isStopped && observer.onCompleted();
-                }
-              }));
-          },
-          function (e) { observer.onError(e); },
-          function () {
-            isStopped = true;
-            !hasLatest && observer.onCompleted();
-          });
-      return new CompositeDisposable(subscription, innerSubscription);
-    }, sources);
+    return new SwitchObservable(this);
   };
 
+  var TakeUntilObservable = (function(__super__) {
+    inherits(TakeUntilObservable, __super__);
+
+    function TakeUntilObservable(source, other) {
+      this.source = source;
+      this.other = isPromise(other) ? observableFromPromise(other) : other;
+      __super__.call(this);
+    }
+
+    TakeUntilObservable.prototype.subscribeCore = function(o) {
+      return new CompositeDisposable(
+        this.source.subscribe(o),
+        this.other.subscribe(new InnerObserver(o))
+      );
+    };
+
+    function InnerObserver(o) {
+      this.o = o;
+      this.isStopped = false;
+    }
+    InnerObserver.prototype.onNext = function (x) {
+      if (this.isStopped) { return; }
+      this.o.onCompleted();
+    };
+    InnerObserver.prototype.onError = function (err) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(err);
+      }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      !this.isStopped && (this.isStopped = true);
+    };
+    InnerObserver.prototype.dispose = function() { this.isStopped = true; };
+    InnerObserver.prototype.fail = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+      return false;
+    };
+
+    return TakeUntilObservable;
+  }(ObservableBase));
+
   /**
    * Returns the values from the source observable sequence until the other observable sequence produces a value.
    * @param {Observable | Promise} other Observable sequence or Promise that terminates propagation of elements of the source sequence.
    * @returns {Observable} An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation.
    */
   observableProto.takeUntil = function (other) {
-    var source = this;
-    return new AnonymousObservable(function (o) {
-      isPromise(other) && (other = observableFromPromise(other));
-      return new CompositeDisposable(
-        source.subscribe(o),
-        other.subscribe(function () { o.onCompleted(); }, function (e) { o.onError(e); }, noop)
-      );
-    }, source);
+    return new TakeUntilObservable(this, other);
   };
 
+  function falseFactory() { return false; }
+
   /**
    * Merges the specified observable sequences into one observable sequence by using the selector function only when the (first) source observable sequence produces an element.
-   *
-   * @example
-   * 1 - obs = obs1.withLatestFrom(obs2, obs3, function (o1, o2, o3) { return o1 + o2 + o3; });
-   * 2 - obs = obs1.withLatestFrom([obs2, obs3], function (o1, o2, o3) { return o1 + o2 + o3; });
    * @returns {Observable} An observable sequence containing the result of combining elements of the sources using the specified result selector function.
    */
   observableProto.withLatestFrom = function () {
     var len = arguments.length, args = new Array(len)
     for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
     var resultSelector = args.pop(), source = this;
-
-    if (typeof source === 'undefined') {
-      throw new Error('Source observable not found for withLatestFrom().');
-    }
-    if (typeof resultSelector !== 'function') {
-      throw new Error('withLatestFrom() expects a resultSelector function.');
-    }
-    if (Array.isArray(args[0])) {
-      args = args[0];
-    }
+    Array.isArray(args[0]) && (args = args[0]);
 
     return new AnonymousObservable(function (observer) {
-      var falseFactory = function () { return false; },
-        n = args.length,
+      var n = args.length,
         hasValue = arrayInitialize(n, falseFactory),
         hasValueAll = false,
         values = new Array(n);
@@ -3440,24 +3598,19 @@
             values[i] = x;
             hasValue[i] = true;
             hasValueAll = hasValue.every(identity);
-          }, observer.onError.bind(observer), function () {}));
+          }, function (e) { observer.onError(e); }, noop));
           subscriptions[i] = sad;
         }(idx));
       }
 
       var sad = new SingleAssignmentDisposable();
       sad.setDisposable(source.subscribe(function (x) {
-        var res;
         var allValues = [x].concat(values);
-        if (!hasValueAll) return;
-        try {
-          res = resultSelector.apply(null, allValues);
-        } catch (ex) {
-          observer.onError(ex);
-          return;
-        }
+        if (!hasValueAll) { return; }
+        var res = tryCatch(resultSelector).apply(null, allValues);
+        if (res === errorObj) { return observer.onError(res.e); }
         observer.onNext(res);
-      }, observer.onError.bind(observer), function () {
+      }, function (e) { observer.onError(e); }, function () {
         observer.onCompleted();
       }));
       subscriptions[n] = sad;
@@ -3466,83 +3619,54 @@
     }, this);
   };
 
-  function zipArray(second, resultSelector) {
-    var first = this;
-    return new AnonymousObservable(function (observer) {
-      var index = 0, len = second.length;
-      return first.subscribe(function (left) {
-        if (index < len) {
-          var right = second[index++], result;
-          try {
-            result = resultSelector(left, right);
-          } catch (e) {
-            return observer.onError(e);
-          }
-          observer.onNext(result);
-        } else {
-          observer.onCompleted();
-        }
-      }, function (e) { observer.onError(e); }, function () { observer.onCompleted(); });
-    }, first);
-  }
-
   function falseFactory() { return false; }
   function emptyArrayFactory() { return []; }
+  function argumentsToArray() {
+    var len = arguments.length, args = new Array(len);
+    for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+    return args;
+  }
 
   /**
    * Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.
    * The last element in the arguments must be a function to invoke for each series of elements at corresponding indexes in the args.
-   *
-   * @example
-   * 1 - res = obs1.zip(obs2, fn);
-   * 1 - res = x1.zip([1,2,3], fn);
    * @returns {Observable} An observable sequence containing the result of combining elements of the args using the specified result selector function.
    */
   observableProto.zip = function () {
-    if (Array.isArray(arguments[0])) { return zipArray.apply(this, arguments); }
+    if (arguments.length === 0) { throw new Error('invalid arguments'); }
+
     var len = arguments.length, args = new Array(len);
     for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+    var resultSelector = isFunction(args[len - 1]) ? args.pop() : argumentsToArray;
+    Array.isArray(args[0]) && (args = args[0]);
 
-    var parent = this, resultSelector = args.pop();
+    var parent = this;
     args.unshift(parent);
-    return new AnonymousObservable(function (observer) {
+    return new AnonymousObservable(function (o) {
       var n = args.length,
         queues = arrayInitialize(n, emptyArrayFactory),
         isDone = arrayInitialize(n, falseFactory);
 
-      function next(i) {
-        var res, queuedValues;
-        if (queues.every(function (x) { return x.length > 0; })) {
-          try {
-            queuedValues = queues.map(function (x) { return x.shift(); });
-            res = resultSelector.apply(parent, queuedValues);
-          } catch (ex) {
-            observer.onError(ex);
-            return;
-          }
-          observer.onNext(res);
-        } else if (isDone.filter(function (x, j) { return j !== i; }).every(identity)) {
-          observer.onCompleted();
-        }
-      };
-
-      function done(i) {
-        isDone[i] = true;
-        if (isDone.every(function (x) { return x; })) {
-          observer.onCompleted();
-        }
-      }
-
       var subscriptions = new Array(n);
       for (var idx = 0; idx < n; idx++) {
         (function (i) {
           var source = args[i], sad = new SingleAssignmentDisposable();
+
           isPromise(source) && (source = observableFromPromise(source));
+
           sad.setDisposable(source.subscribe(function (x) {
             queues[i].push(x);
-            next(i);
-          }, function (e) { observer.onError(e); }, function () {
-            done(i);
+            if (queues.every(function (x) { return x.length > 0; })) {
+              var queuedValues = queues.map(function (x) { return x.shift(); }),
+                  res = tryCatch(resultSelector).apply(parent, queuedValues);
+              if (res === errorObj) { return o.onError(res.e); }
+              o.onNext(res);
+            } else if (isDone.filter(function (x, j) { return j !== i; }).every(identity)) {
+              o.onCompleted();
+            }
+          }, function (e) { o.onError(e); }, function () {
+            isDone[i] = true;
+            isDone.every(identity) && o.onCompleted();
           }));
           subscriptions[i] = sad;
         })(idx);
@@ -3565,67 +3689,72 @@
     return first.zip.apply(first, args);
   };
 
-  /**
-   * Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes.
-   * @param arguments Observable sources.
-   * @returns {Observable} An observable sequence containing lists of elements at corresponding indexes.
-   */
-  Observable.zipArray = function () {
-    var sources;
-    if (Array.isArray(arguments[0])) {
-      sources = arguments[0];
-    } else {
-      var len = arguments.length;
-      sources = new Array(len);
-      for(var i = 0; i < len; i++) { sources[i] = arguments[i]; }
+function falseFactory() { return false; }
+function emptyArrayFactory() { return []; }
+function argumentsToArray() {
+  var len = arguments.length, args = new Array(len);
+  for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+  return args;
+}
+
+/**
+ * Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences or an array have produced an element at a corresponding index.
+ * The last element in the arguments must be a function to invoke for each series of elements at corresponding indexes in the args.
+ * @returns {Observable} An observable sequence containing the result of combining elements of the args using the specified result selector function.
+ */
+observableProto.zipIterable = function () {
+  if (arguments.length === 0) { throw new Error('invalid arguments'); }
+
+  var len = arguments.length, args = new Array(len);
+  for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+  var resultSelector = isFunction(args[len - 1]) ? args.pop() : argumentsToArray;
+
+  var parent = this;
+  args.unshift(parent);
+  return new AnonymousObservable(function (o) {
+    var n = args.length,
+      queues = arrayInitialize(n, emptyArrayFactory),
+      isDone = arrayInitialize(n, falseFactory);
+
+    var subscriptions = new Array(n);
+    for (var idx = 0; idx < n; idx++) {
+      (function (i) {
+        var source = args[i], sad = new SingleAssignmentDisposable();
+
+        (isArrayLike(source) || isIterable(source)) && (source = observableFrom(source));
+
+        sad.setDisposable(source.subscribe(function (x) {
+          queues[i].push(x);
+          if (queues.every(function (x) { return x.length > 0; })) {
+            var queuedValues = queues.map(function (x) { return x.shift(); }),
+                res = tryCatch(resultSelector).apply(parent, queuedValues);
+            if (res === errorObj) { return o.onError(res.e); }
+            o.onNext(res);
+          } else if (isDone.filter(function (x, j) { return j !== i; }).every(identity)) {
+            o.onCompleted();
+          }
+        }, function (e) { o.onError(e); }, function () {
+          isDone[i] = true;
+          isDone.every(identity) && o.onCompleted();
+        }));
+        subscriptions[i] = sad;
+      })(idx);
     }
-    return new AnonymousObservable(function (observer) {
-      var n = sources.length,
-        queues = arrayInitialize(n, function () { return []; }),
-        isDone = arrayInitialize(n, function () { return false; });
-
-      function next(i) {
-        if (queues.every(function (x) { return x.length > 0; })) {
-          var res = queues.map(function (x) { return x.shift(); });
-          observer.onNext(res);
-        } else if (isDone.filter(function (x, j) { return j !== i; }).every(identity)) {
-          observer.onCompleted();
-          return;
-        }
-      };
-
-      function done(i) {
-        isDone[i] = true;
-        if (isDone.every(identity)) {
-          observer.onCompleted();
-          return;
-        }
-      }
 
-      var subscriptions = new Array(n);
-      for (var idx = 0; idx < n; idx++) {
-        (function (i) {
-          subscriptions[i] = new SingleAssignmentDisposable();
-          subscriptions[i].setDisposable(sources[i].subscribe(function (x) {
-            queues[i].push(x);
-            next(i);
-          }, function (e) { observer.onError(e); }, function () {
-            done(i);
-          }));
-        })(idx);
-      }
+    return new CompositeDisposable(subscriptions);
+  }, parent);
+};
 
-      return new CompositeDisposable(subscriptions);
-    });
-  };
+  function asObservable(source) {
+    return function subscribe(o) { return source.subscribe(o); };
+  }
 
   /**
    *  Hides the identity of an observable sequence.
    * @returns {Observable} An observable sequence that hides the identity of the source sequence.
    */
   observableProto.asObservable = function () {
-    var source = this;
-    return new AnonymousObservable(function (o) { return source.subscribe(o); }, this);
+    return new AnonymousObservable(asObservable(this), this);
   };
 
   /**
@@ -3639,118 +3768,167 @@
     }, this);
   };
 
+  var DistinctUntilChangedObservable = (function(__super__) {
+    inherits(DistinctUntilChangedObservable, __super__);
+    function DistinctUntilChangedObservable(source, keyFn, comparer) {
+      this.source = source;
+      this.keyFn = keyFn;
+      this.comparer = comparer;
+      __super__.call(this);
+    }
+
+    DistinctUntilChangedObservable.prototype.subscribeCore = function (o) {
+      return this.source.subscribe(new DistinctUntilChangedObserver(o, this.keyFn, this.comparer));
+    };
+
+    return DistinctUntilChangedObservable;
+  }(ObservableBase));
+
+  var DistinctUntilChangedObserver = (function(__super__) {
+    inherits(DistinctUntilChangedObserver, __super__);
+    function DistinctUntilChangedObserver(o, keyFn, comparer) {
+      this.o = o;
+      this.keyFn = keyFn;
+      this.comparer = comparer;
+      this.hasCurrentKey = false;
+      this.currentKey = null;
+      __super__.call(this);
+    }
+
+    DistinctUntilChangedObserver.prototype.next = function (x) {
+      var key = x, comparerEquals;
+      if (isFunction(this.keyFn)) {
+        key = tryCatch(this.keyFn)(x);
+        if (key === errorObj) { return this.o.onError(key.e); }
+      }
+      if (this.hasCurrentKey) {
+        comparerEquals = tryCatch(this.comparer)(this.currentKey, key);
+        if (comparerEquals === errorObj) { return this.o.onError(comparerEquals.e); }
+      }
+      if (!this.hasCurrentKey || !comparerEquals) {
+        this.hasCurrentKey = true;
+        this.currentKey = key;
+        this.o.onNext(x);
+      }
+    };
+    DistinctUntilChangedObserver.prototype.error = function(e) {
+      this.o.onError(e);
+    };
+    DistinctUntilChangedObserver.prototype.completed = function () {
+      this.o.onCompleted();
+    };
+
+    return DistinctUntilChangedObserver;
+  }(AbstractObserver));
+
   /**
-   *  Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer.
-   *
-   *  var obs = observable.distinctUntilChanged();
-   *  var obs = observable.distinctUntilChanged(function (x) { return x.id; });
-   *  var obs = observable.distinctUntilChanged(function (x) { return x.id; }, function (x, y) { return x === y; });
-   *
-   * @param {Function} [keySelector] A function to compute the comparison key for each element. If not provided, it projects the value.
-   * @param {Function} [comparer] Equality comparer for computed key values. If not provided, defaults to an equality comparer function.
-   * @returns {Observable} An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence.
-   */
-  observableProto.distinctUntilChanged = function (keySelector, comparer) {
-    var source = this;
+  *  Returns an observable sequence that contains only distinct contiguous elements according to the keyFn and the comparer.
+  * @param {Function} [keyFn] A function to compute the comparison key for each element. If not provided, it projects the value.
+  * @param {Function} [comparer] Equality comparer for computed key values. If not provided, defaults to an equality comparer function.
+  * @returns {Observable} An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence.
+  */
+  observableProto.distinctUntilChanged = function (keyFn, comparer) {
     comparer || (comparer = defaultComparer);
-    return new AnonymousObservable(function (o) {
-      var hasCurrentKey = false, currentKey;
-      return source.subscribe(function (value) {
-        var key = value;
-        if (keySelector) {
-          try {
-            key = keySelector(value);
-          } catch (e) {
-            o.onError(e);
-            return;
-          }
-        }
-        if (hasCurrentKey) {
-          try {
-            var comparerEquals = comparer(currentKey, key);
-          } catch (e) {
-            o.onError(e);
-            return;
-          }
-        }
-        if (!hasCurrentKey || !comparerEquals) {
-          hasCurrentKey = true;
-          currentKey = key;
-          o.onNext(value);
-        }
-      }, function (e) { o.onError(e); }, function () { o.onCompleted(); });
-    }, this);
+    return new DistinctUntilChangedObservable(this, keyFn, comparer);
   };
 
+  var TapObservable = (function(__super__) {
+    inherits(TapObservable,__super__);
+    function TapObservable(source, observerOrOnNext, onError, onCompleted) {
+      this.source = source;
+      this._oN = observerOrOnNext;
+      this._oE = onError;
+      this._oC = onCompleted;
+      __super__.call(this);
+    }
+
+    TapObservable.prototype.subscribeCore = function(o) {
+      return this.source.subscribe(new InnerObserver(o, this));
+    };
+
+    function InnerObserver(o, p) {
+      this.o = o;
+      this.t = !p._oN || isFunction(p._oN) ?
+        observerCreate(p._oN || noop, p._oE || noop, p._oC || noop) :
+        p._oN;
+      this.isStopped = false;
+    }
+    InnerObserver.prototype.onNext = function(x) {
+      if (this.isStopped) { return; }
+      var res = tryCatch(this.t.onNext).call(this.t, x);
+      if (res === errorObj) { this.o.onError(res.e); }
+      this.o.onNext(x);
+    };
+    InnerObserver.prototype.onError = function(err) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        var res = tryCatch(this.t.onError).call(this.t, err);
+        if (res === errorObj) { return this.o.onError(res.e); }
+        this.o.onError(err);
+      }
+    };
+    InnerObserver.prototype.onCompleted = function() {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        var res = tryCatch(this.t.onCompleted).call(this.t);
+        if (res === errorObj) { return this.o.onError(res.e); }
+        this.o.onCompleted();
+      }
+    };
+    InnerObserver.prototype.dispose = function() { this.isStopped = true; };
+    InnerObserver.prototype.fail = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+      return false;
+    };
+
+    return TapObservable;
+  }(ObservableBase));
+
   /**
-   *  Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.
-   *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
-   * @param {Function | Observer} observerOrOnNext Action to invoke for each element in the observable sequence or an observer.
-   * @param {Function} [onError]  Action to invoke upon exceptional termination of the observable sequence. Used if only the observerOrOnNext parameter is also a function.
-   * @param {Function} [onCompleted]  Action to invoke upon graceful termination of the observable sequence. Used if only the observerOrOnNext parameter is also a function.
-   * @returns {Observable} The source sequence with the side-effecting behavior applied.
-   */
+  *  Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence.
+  *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
+  * @param {Function | Observer} observerOrOnNext Action to invoke for each element in the observable sequence or an o.
+  * @param {Function} [onError]  Action to invoke upon exceptional termination of the observable sequence. Used if only the observerOrOnNext parameter is also a function.
+  * @param {Function} [onCompleted]  Action to invoke upon graceful termination of the observable sequence. Used if only the observerOrOnNext parameter is also a function.
+  * @returns {Observable} The source sequence with the side-effecting behavior applied.
+  */
   observableProto['do'] = observableProto.tap = observableProto.doAction = function (observerOrOnNext, onError, onCompleted) {
-    var source = this;
-    return new AnonymousObservable(function (observer) {
-      var tapObserver = !observerOrOnNext || isFunction(observerOrOnNext) ?
-        observerCreate(observerOrOnNext || noop, onError || noop, onCompleted || noop) :
-        observerOrOnNext;
-
-      return source.subscribe(function (x) {
-        try {
-          tapObserver.onNext(x);
-        } catch (e) {
-          observer.onError(e);
-        }
-        observer.onNext(x);
-      }, function (err) {
-          try {
-            tapObserver.onError(err);
-          } catch (e) {
-            observer.onError(e);
-          }
-        observer.onError(err);
-      }, function () {
-        try {
-          tapObserver.onCompleted();
-        } catch (e) {
-          observer.onError(e);
-        }
-        observer.onCompleted();
-      });
-    }, this);
+    return new TapObservable(this, observerOrOnNext, onError, onCompleted);
   };
 
   /**
-   *  Invokes an action for each element in the observable sequence.
-   *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
-   * @param {Function} onNext Action to invoke for each element in the observable sequence.
-   * @param {Any} [thisArg] Object to use as this when executing callback.
-   * @returns {Observable} The source sequence with the side-effecting behavior applied.
-   */
+  *  Invokes an action for each element in the observable sequence.
+  *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
+  * @param {Function} onNext Action to invoke for each element in the observable sequence.
+  * @param {Any} [thisArg] Object to use as this when executing callback.
+  * @returns {Observable} The source sequence with the side-effecting behavior applied.
+  */
   observableProto.doOnNext = observableProto.tapOnNext = function (onNext, thisArg) {
     return this.tap(typeof thisArg !== 'undefined' ? function (x) { onNext.call(thisArg, x); } : onNext);
   };
 
   /**
-   *  Invokes an action upon exceptional termination of the observable sequence.
-   *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
-   * @param {Function} onError Action to invoke upon exceptional termination of the observable sequence.
-   * @param {Any} [thisArg] Object to use as this when executing callback.
-   * @returns {Observable} The source sequence with the side-effecting behavior applied.
-   */
+  *  Invokes an action upon exceptional termination of the observable sequence.
+  *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
+  * @param {Function} onError Action to invoke upon exceptional termination of the observable sequence.
+  * @param {Any} [thisArg] Object to use as this when executing callback.
+  * @returns {Observable} The source sequence with the side-effecting behavior applied.
+  */
   observableProto.doOnError = observableProto.tapOnError = function (onError, thisArg) {
     return this.tap(noop, typeof thisArg !== 'undefined' ? function (e) { onError.call(thisArg, e); } : onError);
   };
 
   /**
-   *  Invokes an action upon graceful termination of the observable sequence.
-   *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
-   * @param {Function} onCompleted Action to invoke upon graceful termination of the observable sequence.
-   * @param {Any} [thisArg] Object to use as this when executing callback.
-   * @returns {Observable} The source sequence with the side-effecting behavior applied.
-   */
+  *  Invokes an action upon graceful termination of the observable sequence.
+  *  This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline.
+  * @param {Function} onCompleted Action to invoke upon graceful termination of the observable sequence.
+  * @param {Any} [thisArg] Object to use as this when executing callback.
+  * @returns {Observable} The source sequence with the side-effecting behavior applied.
+  */
   observableProto.doOnCompleted = observableProto.tapOnCompleted = function (onCompleted, thisArg) {
     return this.tap(noop, null, typeof thisArg !== 'undefined' ? function () { onCompleted.call(thisArg); } : onCompleted);
   };
@@ -3760,45 +3938,71 @@
    * @param {Function} finallyAction Action to invoke after the source observable sequence terminates.
    * @returns {Observable} Source sequence with the action-invoking termination behavior applied.
    */
-  observableProto['finally'] = observableProto.ensure = function (action) {
+  observableProto['finally'] = function (action) {
     var source = this;
     return new AnonymousObservable(function (observer) {
-      var subscription;
-      try {
-        subscription = source.subscribe(observer);
-      } catch (e) {
+      var subscription = tryCatch(source.subscribe).call(source, observer);
+      if (subscription === errorObj) {
         action();
-        throw e;
+        return thrower(subscription.e);
       }
       return disposableCreate(function () {
-        try {
-          subscription.dispose();
-        } catch (e) {
-          throw e;
-        } finally {
-          action();
-        }
+        var r = tryCatch(subscription.dispose).call(subscription);
+        action();
+        r === errorObj && thrower(r.e);
       });
     }, this);
   };
 
-  /**
-   * @deprecated use #finally or #ensure instead.
-   */
-  observableProto.finallyAction = function (action) {
-    //deprecate('finallyAction', 'finally or ensure');
-    return this.ensure(action);
-  };
+  var IgnoreElementsObservable = (function(__super__) {
+    inherits(IgnoreElementsObservable, __super__);
+
+    function IgnoreElementsObservable(source) {
+      this.source = source;
+      __super__.call(this);
+    }
+
+    IgnoreElementsObservable.prototype.subscribeCore = function (o) {
+      return this.source.subscribe(new InnerObserver(o));
+    };
+
+    function InnerObserver(o) {
+      this.o = o;
+      this.isStopped = false;
+    }
+    InnerObserver.prototype.onNext = noop;
+    InnerObserver.prototype.onError = function (err) {
+      if(!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(err);
+      }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      if(!this.isStopped) {
+        this.isStopped = true;
+        this.o.onCompleted();
+      }
+    };
+    InnerObserver.prototype.dispose = function() { this.isStopped = true; };
+    InnerObserver.prototype.fail = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.observer.onError(e);
+        return true;
+      }
+
+      return false;
+    };
+
+    return IgnoreElementsObservable;
+  }(ObservableBase));
 
   /**
    *  Ignores all elements in an observable sequence leaving only the termination messages.
    * @returns {Observable} An empty observable sequence that signals termination, successful or exceptional, of the source sequence.
    */
   observableProto.ignoreElements = function () {
-    var source = this;
-    return new AnonymousObservable(function (o) {
-      return source.subscribe(noop, function (e) { o.onError(e); }, function () { o.onCompleted(); });
-    }, source);
+    return new IgnoreElementsObservable(this);
   };
 
   /**
@@ -3856,51 +4060,84 @@
   observableProto.retryWhen = function (notifier) {
     return enumerableRepeat(this).catchErrorWhen(notifier);
   };
+  var ScanObservable = (function(__super__) {
+    inherits(ScanObservable, __super__);
+    function ScanObservable(source, accumulator, hasSeed, seed) {
+      this.source = source;
+      this.accumulator = accumulator;
+      this.hasSeed = hasSeed;
+      this.seed = seed;
+      __super__.call(this);
+    }
+
+    ScanObservable.prototype.subscribeCore = function(o) {
+      return this.source.subscribe(new InnerObserver(o,this));
+    };
+
+    return ScanObservable;
+  }(ObservableBase));
+
+  function InnerObserver(o, parent) {
+    this.o = o;
+    this.accumulator = parent.accumulator;
+    this.hasSeed = parent.hasSeed;
+    this.seed = parent.seed;
+    this.hasAccumulation = false;
+    this.accumulation = null;
+    this.hasValue = false;
+    this.isStopped = false;
+  }
+  InnerObserver.prototype = {
+    onNext: function (x) {
+      if (this.isStopped) { return; }
+      !this.hasValue && (this.hasValue = true);
+      if (this.hasAccumulation) {
+        this.accumulation = tryCatch(this.accumulator)(this.accumulation, x);
+      } else {
+        this.accumulation = this.hasSeed ? tryCatch(this.accumulator)(this.seed, x) : x;
+        this.hasAccumulation = true;
+      }
+      if (this.accumulation === errorObj) { return this.o.onError(this.accumulation.e); }
+      this.o.onNext(this.accumulation);
+    },
+    onError: function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+      }
+    },
+    onCompleted: function () {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        !this.hasValue && this.hasSeed && this.o.onNext(this.seed);
+        this.o.onCompleted();
+      }
+    },
+    dispose: function() { this.isStopped = true; },
+    fail: function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+      return false;
+    }
+  };
+
   /**
-   *  Applies an accumulator function over an observable sequence and returns each intermediate result. The optional seed value is used as the initial accumulator value.
-   *  For aggregation behavior with no intermediate results, see Observable.aggregate.
-   * @example
-   *  var res = source.scan(function (acc, x) { return acc + x; });
-   *  var res = source.scan(0, function (acc, x) { return acc + x; });
-   * @param {Mixed} [seed] The initial accumulator value.
-   * @param {Function} accumulator An accumulator function to be invoked on each element.
-   * @returns {Observable} An observable sequence containing the accumulated values.
-   */
+  *  Applies an accumulator function over an observable sequence and returns each intermediate result. The optional seed value is used as the initial accumulator value.
+  *  For aggregation behavior with no intermediate results, see Observable.aggregate.
+  * @param {Mixed} [seed] The initial accumulator value.
+  * @param {Function} accumulator An accumulator function to be invoked on each element.
+  * @returns {Observable} An observable sequence containing the accumulated values.
+  */
   observableProto.scan = function () {
-    var hasSeed = false, seed, accumulator, source = this;
+    var hasSeed = false, seed, accumulator = arguments[0];
     if (arguments.length === 2) {
       hasSeed = true;
-      seed = arguments[0];
-      accumulator = arguments[1];
-    } else {
-      accumulator = arguments[0];
+      seed = arguments[1];
     }
-    return new AnonymousObservable(function (o) {
-      var hasAccumulation, accumulation, hasValue;
-      return source.subscribe (
-        function (x) {
-          !hasValue && (hasValue = true);
-          try {
-            if (hasAccumulation) {
-              accumulation = accumulator(accumulation, x);
-            } else {
-              accumulation = hasSeed ? accumulator(seed, x) : x;
-              hasAccumulation = true;
-            }
-          } catch (e) {
-            o.onError(e);
-            return;
-          }
-
-          o.onNext(accumulation);
-        },
-        function (e) { o.onError(e); },
-        function () {
-          !hasValue && hasSeed && o.onNext(seed);
-          o.onCompleted();
-        }
-      );
-    }, source);
+    return new ScanObservable(this, accumulator, hasSeed, seed);
   };
 
   /**
@@ -3966,52 +4203,9 @@
     }, source);
   };
 
-  function concatMap(source, selector, thisArg) {
-    var selectorFunc = bindCallback(selector, thisArg, 3);
-    return source.map(function (x, i) {
-      var result = selectorFunc(x, i, source);
-      isPromise(result) && (result = observableFromPromise(result));
-      (isArrayLike(result) || isIterable(result)) && (result = observableFrom(result));
-      return result;
-    }).concatAll();
-  }
-
-  /**
-   *  One of the Following:
-   *  Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
-   *
-   * @example
-   *  var res = source.concatMap(function (x) { return Rx.Observable.range(0, x); });
-   *  Or:
-   *  Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.
-   *
-   *  var res = source.concatMap(function (x) { return Rx.Observable.range(0, x); }, function (x, y) { return x + y; });
-   *  Or:
-   *  Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
-   *
-   *  var res = source.concatMap(Rx.Observable.fromArray([1,2,3]));
-   * @param {Function} selector A transform function to apply to each element or an observable sequence to project each element from the
-   * source sequence onto which could be either an observable or Promise.
-   * @param {Function} [resultSelector]  A transform function to apply to each element of the intermediate sequence.
-   * @returns {Observable} An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.
-   */
-  observableProto.selectConcat = observableProto.concatMap = function (selector, resultSelector, thisArg) {
-    if (isFunction(selector) && isFunction(resultSelector)) {
-      return this.concatMap(function (x, i) {
-        var selectorResult = selector(x, i);
-        isPromise(selectorResult) && (selectorResult = observableFromPromise(selectorResult));
-        (isArrayLike(selectorResult) || isIterable(selectorResult)) && (selectorResult = observableFrom(selectorResult));
-
-        return selectorResult.map(function (y, i2) {
-          return resultSelector(x, y, i, i2);
-        });
-      });
-    }
-    return isFunction(selector) ?
-      concatMap(this, selector, thisArg) :
-      concatMap(this, function () { return selector; });
-  };
-
+observableProto.flatMapConcat = observableProto.concatMap = function(selector, resultSelector, thisArg) {
+    return new FlatMapObservable(this, selector, resultSelector, thisArg).merge(1);
+};
   var MapObservable = (function (__super__) {
     inherits(MapObservable, __super__);
 
@@ -4021,51 +4215,52 @@
       __super__.call(this);
     }
 
+    function innerMap(selector, self) {
+      return function (x, i, o) { return selector.call(this, self.selector(x, i, o), i, o); }
+    }
+
     MapObservable.prototype.internalMap = function (selector, thisArg) {
-      var self = this;
-      return new MapObservable(this.source, function (x, i, o) { return selector.call(this, self.selector(x, i, o), i, o); }, thisArg)
+      return new MapObservable(this.source, innerMap(selector, this), thisArg);
     };
 
-    MapObservable.prototype.subscribeCore = function (observer) {
-      return this.source.subscribe(new MapObserver(observer, this.selector, this));
+    MapObservable.prototype.subscribeCore = function (o) {
+      return this.source.subscribe(new InnerObserver(o, this.selector, this));
     };
 
-    return MapObservable;
+    function InnerObserver(o, selector, source) {
+      this.o = o;
+      this.selector = selector;
+      this.source = source;
+      this.i = 0;
+      this.isStopped = false;
+    }
 
-  }(ObservableBase));
+    InnerObserver.prototype.onNext = function(x) {
+      if (this.isStopped) { return; }
+      var result = tryCatch(this.selector)(x, this.i++, this.source);
+      if (result === errorObj) { return this.o.onError(result.e); }
+      this.o.onNext(result);
+    };
+    InnerObserver.prototype.onError = function (e) {
+      if(!this.isStopped) { this.isStopped = true; this.o.onError(e); }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      if(!this.isStopped) { this.isStopped = true; this.o.onCompleted(); }
+    };
+    InnerObserver.prototype.dispose = function() { this.isStopped = true; };
+    InnerObserver.prototype.fail = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
 
-  function MapObserver(observer, selector, source) {
-    this.observer = observer;
-    this.selector = selector;
-    this.source = source;
-    this.i = 0;
-    this.isStopped = false;
-  }
+      return false;
+    };
 
-  MapObserver.prototype.onNext = function(x) {
-    if (this.isStopped) { return; }
-    var result = tryCatch(this.selector).call(this, x, this.i++, this.source);
-    if (result === errorObj) {
-      return this.observer.onError(result.e);
-    }
-    this.observer.onNext(result);
-  };
-  MapObserver.prototype.onError = function (e) {
-    if(!this.isStopped) { this.isStopped = true; this.observer.onError(e); }
-  };
-  MapObserver.prototype.onCompleted = function () {
-    if(!this.isStopped) { this.isStopped = true; this.observer.onCompleted(); }
-  };
-  MapObserver.prototype.dispose = function() { this.isStopped = true; };
-  MapObserver.prototype.fail = function (e) {
-    if (!this.isStopped) {
-      this.isStopped = true;
-      this.observer.onError(e);
-      return true;
-    }
+    return MapObservable;
 
-    return false;
-  };
+  }(ObservableBase));
 
   /**
   * Projects each element of an observable sequence into a new form by incorporating the element's index.
@@ -4080,16 +4275,8 @@
       new MapObservable(this, selectorFn, thisArg);
   };
 
-  /**
-   * Retrieves the value of a specified nested property from all elements in
-   * the Observable sequence.
-   * @param {Arguments} arguments The nested properties to pluck.
-   * @returns {Observable} Returns a new Observable sequence of property values.
-   */
-  observableProto.pluck = function () {
-    var args = arguments, len = arguments.length;
-    if (len === 0) { throw new Error('List of properties cannot be empty.'); }
-    return this.map(function (x) {
+  function plucker(args, len) {
+    return function mapper(x) {
       var currentProp = x;
       for (var i = 0; i < len; i++) {
         var p = currentProp[args[i]];
@@ -4100,87 +4287,90 @@
         }
       }
       return currentProp;
-    });
-  };
-
-  function flatMap(source, selector, thisArg) {
-    var selectorFunc = bindCallback(selector, thisArg, 3);
-    return source.map(function (x, i) {
-      var result = selectorFunc(x, i, source);
-      isPromise(result) && (result = observableFromPromise(result));
-      (isArrayLike(result) || isIterable(result)) && (result = observableFrom(result));
-      return result;
-    }).mergeAll();
+    }
   }
 
   /**
-   *  One of the Following:
-   *  Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
-   *
-   * @example
-   *  var res = source.selectMany(function (x) { return Rx.Observable.range(0, x); });
-   *  Or:
-   *  Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence.
-   *
-   *  var res = source.selectMany(function (x) { return Rx.Observable.range(0, x); }, function (x, y) { return x + y; });
-   *  Or:
-   *  Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence.
-   *
-   *  var res = source.selectMany(Rx.Observable.fromArray([1,2,3]));
-   * @param {Function} selector A transform function to apply to each element or an observable sequence to project each element from the source sequence onto which could be either an observable or Promise.
-   * @param {Function} [resultSelector]  A transform function to apply to each element of the intermediate sequence.
-   * @param {Any} [thisArg] Object to use as this when executing callback.
-   * @returns {Observable} An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element.
+   * Retrieves the value of a specified nested property from all elements in
+   * the Observable sequence.
+   * @param {Arguments} arguments The nested properties to pluck.
+   * @returns {Observable} Returns a new Observable sequence of property values.
    */
-  observableProto.selectMany = observableProto.flatMap = function (selector, resultSelector, thisArg) {
-    if (isFunction(selector) && isFunction(resultSelector)) {
-      return this.flatMap(function (x, i) {
-        var selectorResult = selector(x, i);
-        isPromise(selectorResult) && (selectorResult = observableFromPromise(selectorResult));
-        (isArrayLike(selectorResult) || isIterable(selectorResult)) && (selectorResult = observableFrom(selectorResult));
-
-        return selectorResult.map(function (y, i2) {
-          return resultSelector(x, y, i, i2);
-        });
-      }, thisArg);
-    }
-    return isFunction(selector) ?
-      flatMap(this, selector, thisArg) :
-      flatMap(this, function () { return selector; });
+  observableProto.pluck = function () {
+    var len = arguments.length, args = new Array(len);
+    if (len === 0) { throw new Error('List of properties cannot be empty.'); }
+    for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+    return this.map(plucker(args, len));
   };
 
-  /**
-   *  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then
-   *  transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
-   * @param {Function} selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
-   * @param {Any} [thisArg] Object to use as this when executing callback.
-   * @returns {Observable} An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences
-   *  and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
-   */
-  observableProto.selectSwitch = observableProto.flatMapLatest = observableProto.switchMap = function (selector, thisArg) {
-    return this.select(selector, thisArg).switchLatest();
-  };
+observableProto.flatMap = observableProto.selectMany = function(selector, resultSelector, thisArg) {
+    return new FlatMapObservable(this, selector, resultSelector, thisArg).mergeAll();
+};
 
-  /**
-   * Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.
-   * @param {Number} count The number of elements to skip before returning the remaining elements.
-   * @returns {Observable} An observable sequence that contains the elements that occur after the specified index in the input sequence.
-   */
-  observableProto.skip = function (count) {
-    if (count < 0) { throw new ArgumentOutOfRangeError(); }
-    var source = this;
-    return new AnonymousObservable(function (o) {
-      var remaining = count;
-      return source.subscribe(function (x) {
-        if (remaining <= 0) {
-          o.onNext(x);
-        } else {
-          remaining--;
-        }
-      }, function (e) { o.onError(e); }, function () { o.onCompleted(); });
-    }, source);
+
+//
+//Rx.Observable.prototype.flatMapWithMaxConcurrent = function(limit, selector, resultSelector, thisArg) {
+//    return new FlatMapObservable(this, selector, resultSelector, thisArg).merge(limit);
+//};
+//
+
+Rx.Observable.prototype.flatMapLatest = function(selector, resultSelector, thisArg) {
+    return new FlatMapObservable(this, selector, resultSelector, thisArg).switchLatest();
+};
+  var SkipObservable = (function(__super__) {
+    inherits(SkipObservable, __super__);
+    function SkipObservable(source, count) {
+      this.source = source;
+      this.skipCount = count;
+      __super__.call(this);
+    }
+    
+    SkipObservable.prototype.subscribeCore = function (o) {
+      return this.source.subscribe(new InnerObserver(o, this.skipCount));
+    };
+    
+    function InnerObserver(o, c) {
+      this.c = c;
+      this.r = c;
+      this.o = o;
+      this.isStopped = false;
+    }
+    InnerObserver.prototype.onNext = function (x) {
+      if (this.isStopped) { return; }
+      if (this.r <= 0) { 
+        this.o.onNext(x);
+      } else {
+        this.r--;
+      }
+    };
+    InnerObserver.prototype.onError = function(e) {
+      if (!this.isStopped) { this.isStopped = true; this.o.onError(e); }
+    };
+    InnerObserver.prototype.onCompleted = function() {
+      if (!this.isStopped) { this.isStopped = true; this.o.onCompleted(); }
+    };
+    InnerObserver.prototype.dispose = function() { this.isStopped = true; };
+    InnerObserver.prototype.fail = function(e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+      return false;
+    };
+    
+    return SkipObservable;
+  }(ObservableBase));  
+  
+  /**
+   * Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.
+   * @param {Number} count The number of elements to skip before returning the remaining elements.
+   * @returns {Observable} An observable sequence that contains the elements that occur after the specified index in the input sequence.
+   */
+  observableProto.skip = function (count) {
+    if (count < 0) { throw new ArgumentOutOfRangeError(); }
+    return new SkipObservable(this, count);
   };
-
   /**
    *  Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements.
    *  The element's index is used in the logic of the predicate function.
@@ -4228,7 +4418,7 @@
       return source.subscribe(function (x) {
         if (remaining-- > 0) {
           o.onNext(x);
-          remaining === 0 && o.onCompleted();
+          remaining <= 0 && o.onCompleted();
         }
       }, function (e) { o.onError(e); }, function () { o.onCompleted(); });
     }, source);
@@ -4273,51 +4463,54 @@
       __super__.call(this);
     }
 
-    FilterObservable.prototype.subscribeCore = function (observer) {
-      return this.source.subscribe(new FilterObserver(observer, this.predicate, this));
+    FilterObservable.prototype.subscribeCore = function (o) {
+      return this.source.subscribe(new InnerObserver(o, this.predicate, this));
     };
+    
+    function innerPredicate(predicate, self) {
+      return function(x, i, o) { return self.predicate(x, i, o) && predicate.call(this, x, i, o); }
+    }
 
     FilterObservable.prototype.internalFilter = function(predicate, thisArg) {
-      var self = this;
-      return new FilterObservable(this.source, function(x, i, o) { return self.predicate(x, i, o) && predicate.call(this, x, i, o); }, thisArg);
+      return new FilterObservable(this.source, innerPredicate(predicate, this), thisArg);
+    };
+    
+    function InnerObserver(o, predicate, source) {
+      this.o = o;
+      this.predicate = predicate;
+      this.source = source;
+      this.i = 0;
+      this.isStopped = false;
+    }
+  
+    InnerObserver.prototype.onNext = function(x) {
+      if (this.isStopped) { return; }
+      var shouldYield = tryCatch(this.predicate)(x, this.i++, this.source);
+      if (shouldYield === errorObj) {
+        return this.o.onError(shouldYield.e);
+      }
+      shouldYield && this.o.onNext(x);
+    };
+    InnerObserver.prototype.onError = function (e) {
+      if(!this.isStopped) { this.isStopped = true; this.o.onError(e); }
+    };
+    InnerObserver.prototype.onCompleted = function () {
+      if(!this.isStopped) { this.isStopped = true; this.o.onCompleted(); }
+    };
+    InnerObserver.prototype.dispose = function() { this.isStopped = true; };
+    InnerObserver.prototype.fail = function (e) {
+      if (!this.isStopped) {
+        this.isStopped = true;
+        this.o.onError(e);
+        return true;
+      }
+      return false;
     };
 
     return FilterObservable;
 
   }(ObservableBase));
 
-  function FilterObserver(observer, predicate, source) {
-    this.observer = observer;
-    this.predicate = predicate;
-    this.source = source;
-    this.i = 0;
-    this.isStopped = false;
-  }
-
-  FilterObserver.prototype.onNext = function(x) {
-    if (this.isStopped) { return; }
-    var shouldYield = tryCatch(this.predicate).call(this, x, this.i++, this.source);
-    if (shouldYield === errorObj) {
-      return this.observer.onError(shouldYield.e);
-    }
-    shouldYield && this.observer.onNext(x);
-  };
-  FilterObserver.prototype.onError = function (e) {
-    if(!this.isStopped) { this.isStopped = true; this.observer.onError(e); }
-  };
-  FilterObserver.prototype.onCompleted = function () {
-    if(!this.isStopped) { this.isStopped = true; this.observer.onCompleted(); }
-  };
-  FilterObserver.prototype.dispose = function() { this.isStopped = true; };
-  FilterObserver.prototype.fail = function (e) {
-    if (!this.isStopped) {
-      this.isStopped = true;
-      this.observer.onError(e);
-      return true;
-    }
-    return false;
-  };
-
   /**
   *  Filters the elements of an observable sequence based on a predicate by incorporating the element's index.
   * @param {Function} predicate A function to test each source element for a condition; the second parameter of the function represents the index of the source element.
@@ -4329,94 +4522,112 @@
       new FilterObservable(this, predicate, thisArg);
   };
 
-  /**
-   * Converts a callback function to an observable sequence.
-   *
-   * @param {Function} function Function with a callback as the last parameter to convert to an Observable sequence.
-   * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
-   * @param {Function} [selector] A selector which takes the arguments from the callback to produce a single item to yield on next.
-   * @returns {Function} A function, when executed with the required parameters minus the callback, produces an Observable sequence with a single value of the arguments to the callback as an array.
-   */
-  Observable.fromCallback = function (func, context, selector) {
-    return function () {
-      var len = arguments.length, args = new Array(len)
-      for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+function createCbObservable(fn, ctx, selector, args) {
+  var o = new AsyncSubject();
 
-      return new AnonymousObservable(function (observer) {
-        function handler() {
-          var len = arguments.length, results = new Array(len);
-          for(var i = 0; i < len; i++) { results[i] = arguments[i]; }
-
-          if (selector) {
-            try {
-              results = selector.apply(context, results);
-            } catch (e) {
-              return observer.onError(e);
-            }
+  args.push(createCbHandler(o, ctx, selector));
+  fn.apply(ctx, args);
 
-            observer.onNext(results);
-          } else {
-            if (results.length <= 1) {
-              observer.onNext.apply(observer, results);
-            } else {
-              observer.onNext(results);
-            }
-          }
+  return o.asObservable();
+}
 
-          observer.onCompleted();
-        }
+function createCbHandler(o, ctx, selector) {
+  return function handler () {
+    var len = arguments.length, results = new Array(len);
+    for(var i = 0; i < len; i++) { results[i] = arguments[i]; }
 
-        args.push(handler);
-        func.apply(context, args);
-      }).publishLast().refCount();
-    };
+    if (isFunction(selector)) {
+      results = tryCatch(selector).apply(ctx, results);
+      if (results === errorObj) { return o.onError(results.e); }
+      o.onNext(results);
+    } else {
+      if (results.length <= 1) {
+        o.onNext(results[0]);
+      } else {
+        o.onNext(results);
+      }
+    }
+
+    o.onCompleted();
   };
+}
 
-  /**
-   * Converts a Node.js callback style function to an observable sequence.  This must be in function (err, ...) format.
-   * @param {Function} func The function to call
-   * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
-   * @param {Function} [selector] A selector which takes the arguments from the callback minus the error to produce a single item to yield on next.
-   * @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
-   */
-  Observable.fromNodeCallback = function (func, context, selector) {
-    return function () {
-      var len = arguments.length, args = new Array(len);
-      for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+/**
+ * Converts a callback function to an observable sequence.
+ *
+ * @param {Function} fn Function with a callback as the last parameter to convert to an Observable sequence.
+ * @param {Mixed} [ctx] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+ * @param {Function} [selector] A selector which takes the arguments from the callback to produce a single item to yield on next.
+ * @returns {Function} A function, when executed with the required parameters minus the callback, produces an Observable sequence with a single value of the arguments to the callback as an array.
+ */
+Observable.fromCallback = function (fn, ctx, selector) {
+  return function () {
+    typeof ctx === 'undefined' && (ctx = this); 
 
-      return new AnonymousObservable(function (observer) {
-        function handler(err) {
-          if (err) {
-            observer.onError(err);
-            return;
-          }
+    var len = arguments.length, args = new Array(len)
+    for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+    return createCbObservable(fn, ctx, selector, args);
+  };
+};
 
-          var len = arguments.length, results = [];
-          for(var i = 1; i < len; i++) { results[i - 1] = arguments[i]; }
+function createNodeObservable(fn, ctx, selector, args) {
+  var o = new AsyncSubject();
 
-          if (selector) {
-            try {
-              results = selector.apply(context, results);
-            } catch (e) {
-              return observer.onError(e);
-            }
-            observer.onNext(results);
-          } else {
-            if (results.length <= 1) {
-              observer.onNext.apply(observer, results);
-            } else {
-              observer.onNext(results);
-            }
-          }
+  args.push(createNodeHandler(o, ctx, selector));
+  fn.apply(ctx, args);
 
-          observer.onCompleted();
-        }
+  return o.asObservable();
+}
 
-        args.push(handler);
-        func.apply(context, args);
-      }).publishLast().refCount();
-    };
+function createNodeHandler(o, ctx, selector) {
+  return function handler () {
+    var err = arguments[0];
+    if (err) { return o.onError(err); }
+
+    var len = arguments.length, results = [];
+    for(var i = 1; i < len; i++) { results[i - 1] = arguments[i]; }
+
+    if (isFunction(selector)) {
+      var results = tryCatch(selector).apply(ctx, results);
+      if (results === errorObj) { return o.onError(results.e); }
+      o.onNext(results);
+    } else {
+      if (results.length <= 1) {
+        o.onNext(results[0]);
+      } else {
+        o.onNext(results);
+      }
+    }
+
+    o.onCompleted();
+  };
+}
+
+/**
+ * Converts a Node.js callback style function to an observable sequence.  This must be in function (err, ...) format.
+ * @param {Function} fn The function to call
+ * @param {Mixed} [ctx] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+ * @param {Function} [selector] A selector which takes the arguments from the callback minus the error to produce a single item to yield on next.
+ * @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
+ */
+Observable.fromNodeCallback = function (fn, ctx, selector) {
+  return function () {
+    typeof ctx === 'undefined' && (ctx = this); 
+    var len = arguments.length, args = new Array(len);
+    for(var i = 0; i < len; i++) { args[i] = arguments[i]; }
+    return createNodeObservable(fn, ctx, selector, args);
   };
+};
+
+  function isNodeList(el) {
+    if (window.StaticNodeList) {
+      // IE8 Specific
+      // instanceof is slower than Object#toString, but Object#toString will not work as intended in IE8
+      return (el instanceof window.StaticNodeList || el instanceof window.NodeList);
+    } else {
+      return (Object.prototype.toString.call(el) == '[object NodeList]')
+    }
+  }
 
   function fixEvent(event) {
     var stopPropagation = function () {
@@ -4471,36 +4682,61 @@
     return event;
   }
 
-  function createListener (element, name, handler) {
-    // Standards compliant
-    if (element.addEventListener) {
-      element.addEventListener(name, handler, false);
-      return disposableCreate(function () {
-        element.removeEventListener(name, handler, false);
-      });
+  function ListenDisposable(e, n, fn) {
+    this._e = e;
+    this._n = n;
+    this._fn = fn;
+    this._e.addEventListener(this._n, this._fn, false);
+    this.isDisposed = false;
+  }
+  ListenDisposable.prototype.dispose = function () {
+    if (!this.isDisposed) {
+      this._e.removeEventListener(this._n, this._fn, false);
+      this.isDisposed = true;
     }
-    if (element.attachEvent) {
-      // IE Specific
-      var innerHandler = function (event) {
-        handler(fixEvent(event));
-      };
-      element.attachEvent('on' + name, innerHandler);
-      return disposableCreate(function () {
-        element.detachEvent('on' + name, innerHandler);
-      });
+  };
+
+  function AttachEventDisposable(e, n, fn) {
+    this._e = e;
+    this._n = 'on' + n;
+    this._fn = function (e) { fn(fixEvent(e)); };
+    this._e.attachEvent(this._n, this._fn);
+    this.isDisposed = false;
+  }
+  AttachEventDisposable.prototype.dispose = function () {
+    if (!this.isDisposed) {
+      this._e.detachEvent(this._n, this._fn);
+      this.isDisposed = true;
     }
-    // Level 1 DOM Events
-    element['on' + name] = handler;
-    return disposableCreate(function () {
-      element['on' + name] = null;
-    });
+  };
+  function LevelOneDisposable(e, n, fn) {
+    this._e = e;
+    this._n = 'on' + n;
+    this._e[this._n] = fn;
+    this.isDisposed = false;
+  }
+  LevelOneDisposable.prototype.dispose = function () {
+    if (!this.isDisposed) {
+      this._e[this._n] = null;
+      this.isDisposed = true;
+    }
+  };
+
+  function createListener (el, eventName, handler) {
+    if (el.addEventListener) {
+      return new ListenDisposable(el, eventName, handler)
+    }
+    if (el.attachEvent) {
+      return new AttachEventDisposable(el, eventName, handler);
+    }
+    return LevelOneDisposable(el, eventName, handler);
   }
 
   function createEventListener (el, eventName, handler) {
     var disposables = new CompositeDisposable();
 
     // Asume NodeList
-    if (Object.prototype.toString.call(el) === '[object NodeList]') {
+    if (isNodeList(el) || Object.prototype.toString.call(el) === '[object HTMLCollection]') {
       for (var i = 0, len = el.length; i < len; i++) {
         disposables.add(createEventListener(el.item(i), eventName, handler));
       }
@@ -4518,10 +4754,6 @@
 
   /**
    * Creates an observable sequence by adding an event listener to the matching DOMElement or each item in the NodeList.
-   *
-   * @example
-   *   var source = Rx.Observable.fromEvent(element, 'mouseup');
-   *
    * @param {Object} element The DOMElement or NodeList to attach a listener.
    * @param {String} eventName The event name to attach the observable sequence.
    * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
@@ -4546,22 +4778,17 @@
           selector);
       }
     }
-    return new AnonymousObservable(function (observer) {
+    return new AnonymousObservable(function (o) {
       return createEventListener(
         element,
         eventName,
-        function handler (e) {
-          var results = e;
-
-          if (selector) {
-            try {
-              results = selector(arguments);
-            } catch (err) {
-              return observer.onError(err);
-            }
+        function handler () {
+          var results = arguments[0];
+          if (isFunction(selector)) {
+            results = tryCatch(selector).apply(null, arguments);
+            if (results === errorObj) { return o.onError(results.e); }
           }
-
-          observer.onNext(results);
+          o.onNext(results);
         });
     }).publish().refCount();
   };
@@ -4571,51 +4798,54 @@
    * @param {Function} addHandler The function to add a handler to the emitter.
    * @param {Function} [removeHandler] The optional function to remove a handler from an emitter.
    * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
+   * @param {Scheduler} [scheduler] A scheduler used to schedule the remove handler.
    * @returns {Observable} An observable sequence which wraps an event from an event emitter
    */
-  var fromEventPattern = Observable.fromEventPattern = function (addHandler, removeHandler, selector) {
-    return new AnonymousObservable(function (observer) {
-      function innerHandler (e) {
-        var result = e;
-        if (selector) {
-          try {
-            result = selector(arguments);
-          } catch (err) {
-            return observer.onError(err);
-          }
+  var fromEventPattern = Observable.fromEventPattern = function (addHandler, removeHandler, selector, scheduler) {
+    isScheduler(scheduler) || (scheduler = immediateScheduler);
+    return new AnonymousObservable(function (o) {
+      function innerHandler () {
+        var result = arguments[0];
+        if (isFunction(selector)) {
+          result = tryCatch(selector).apply(null, arguments);
+          if (result === errorObj) { return o.onError(result.e); }
         }
-        observer.onNext(result);
+        o.onNext(result);
       }
 
       var returnValue = addHandler(innerHandler);
       return disposableCreate(function () {
-        if (removeHandler) {
-          removeHandler(innerHandler, returnValue);
-        }
+        isFunction(removeHandler) && removeHandler(innerHandler, returnValue);
       });
     }).publish().refCount();
   };
 
-  /**
-   * Converts a Promise to an Observable sequence
-   * @param {Promise} An ES6 Compliant promise.
-   * @returns {Observable} An Observable sequence which wraps the existing promise success and failure.
-   */
-  var observableFromPromise = Observable.fromPromise = function (promise) {
-    return observableDefer(function () {
-      var subject = new Rx.AsyncSubject();
+  var FromPromiseObservable = (function(__super__) {
+    inherits(FromPromiseObservable, __super__);
+    function FromPromiseObservable(p) {
+      this.p = p;
+      __super__.call(this);
+    }
 
-      promise.then(
-        function (value) {
-          subject.onNext(value);
-          subject.onCompleted();
-        },
-        subject.onError.bind(subject));
+    FromPromiseObservable.prototype.subscribeCore = function(o) {
+      this.p.then(function (data) {
+        o.onNext(data);
+        o.onCompleted();
+      }, function (err) { o.onError(err); });
+      return disposableEmpty;
+    };
 
-      return subject;
-    });
-  };
+    return FromPromiseObservable;
+  }(ObservableBase));
 
+  /**
+  * Converts a Promise to an Observable sequence
+  * @param {Promise} An ES6 Compliant promise.
+  * @returns {Observable} An Observable sequence which wraps the existing promise success and failure.
+  */
+  var observableFromPromise = Observable.fromPromise = function (promise) {
+    return new FromPromiseObservable(promise);
+  };
   /*
    * Converts an existing observable sequence to an ES6 Compatible Promise
    * @example
@@ -4907,7 +5137,7 @@
   var observableTimer = Observable.timer = function (dueTime, periodOrScheduler, scheduler) {
     var period;
     isScheduler(scheduler) || (scheduler = timeoutScheduler);
-    if (periodOrScheduler !== undefined && typeof periodOrScheduler === 'number') {
+    if (periodOrScheduler != null && typeof periodOrScheduler === 'number') {
       period = periodOrScheduler;
     } else if (isScheduler(periodOrScheduler)) {
       scheduler = periodOrScheduler;
@@ -4916,8 +5146,7 @@
       return observableTimerDate(dueTime.getTime(), scheduler);
     }
     if (dueTime instanceof Date && period !== undefined) {
-      period = periodOrScheduler;
-      return observableTimerDateAndPeriod(dueTime.getTime(), period, scheduler);
+      return observableTimerDateAndPeriod(dueTime.getTime(), periodOrScheduler, scheduler);
     }
     return period === undefined ?
       observableTimerTimeSpan(dueTime, scheduler) :
@@ -5021,7 +5250,7 @@
    * @param {Scheduler} [scheduler]  Scheduler to run the debounce timers on. If not specified, the timeout scheduler is used.
    * @returns {Observable} The debounced sequence.
    */
-  observableProto.debounce = observableProto.throttleWithTimeout = function (dueTime, scheduler) {
+  observableProto.debounce = function (dueTime, scheduler) {
     isScheduler(scheduler) || (scheduler = timeoutScheduler);
     var source = this;
     return new AnonymousObservable(function (observer) {
@@ -5082,25 +5311,33 @@
   };
 
   function sampleObservable(source, sampler) {
-    return new AnonymousObservable(function (observer) {
-      var atEnd, value, hasValue;
+    return new AnonymousObservable(function (o) {
+      var atEnd = false, value, hasValue = false;
 
       function sampleSubscribe() {
         if (hasValue) {
           hasValue = false;
-          observer.onNext(value);
+          o.onNext(value);
         }
-        atEnd && observer.onCompleted();
+        atEnd && o.onCompleted();
       }
 
-      return new CompositeDisposable(
-        source.subscribe(function (newValue) {
+      var sourceSubscription = new SingleAssignmentDisposable();
+      sourceSubscription.setDisposable(source.subscribe(
+        function (newValue) {
           hasValue = true;
           value = newValue;
-        }, observer.onError.bind(observer), function () {
+        },
+        function (e) { o.onError(e); },
+        function () {
           atEnd = true;
-        }),
-        sampler.subscribe(sampleSubscribe, observer.onError.bind(observer), sampleSubscribe)
+          sourceSubscription.dispose(); 
+        }
+      ));
+
+      return new CompositeDisposable(
+        sourceSubscription,
+        sampler.subscribe(sampleSubscribe, function (e) { o.onError(e); }, sampleSubscribe)
       );
     }, source);
   }
@@ -5273,26 +5510,15 @@
         err;
 
       function next(x, i) {
-        values[i] = x
-        var res;
+        values[i] = x;
         hasValue[i] = true;
         if (hasValueAll || (hasValueAll = hasValue.every(identity))) {
-          if (err) {
-            o.onError(err);
-            return;
-          }
-
-          try {
-            res = resultSelector.apply(null, values);
-          } catch (ex) {
-            o.onError(ex);
-            return;
-          }
+          if (err) { return o.onError(err); }
+          var res = tryCatch(resultSelector).apply(null, values);
+          if (res === errorObj) { return o.onError(res.e); }
           o.onNext(res);
         }
-        if (isDone && values[1]) {
-          o.onCompleted();
-        }
+        isDone && values[1] && o.onCompleted();
       }
 
       return new CompositeDisposable(
@@ -5331,10 +5557,12 @@
     function subscribe(o) {
       var q = [], previousShouldFire;
 
+      function drainQueue() { while (q.length > 0) { o.onNext(q.shift()); } }
+
       var subscription =
         combineLatestSource(
           this.source,
-          this.pauser.distinctUntilChanged().startWith(false),
+          this.pauser.startWith(false).distinctUntilChanged(),
           function (data, shouldFire) {
             return { data: data, shouldFire: shouldFire };
           })
@@ -5343,11 +5571,7 @@
               if (previousShouldFire !== undefined && results.shouldFire != previousShouldFire) {
                 previousShouldFire = results.shouldFire;
                 // change in shouldFire
-                if (results.shouldFire) {
-                  while (q.length > 0) {
-                    o.onNext(q.shift());
-                  }
-                }
+                if (results.shouldFire) { drainQueue(); }
               } else {
                 previousShouldFire = results.shouldFire;
                 // new data
@@ -5359,17 +5583,11 @@
               }
             },
             function (err) {
-              // Empty buffer before sending error
-              while (q.length > 0) {
-                o.onNext(q.shift());
-              }
+              drainQueue();
               o.onError(err);
             },
             function () {
-              // Empty buffer before sending completion
-              while (q.length > 0) {
-                o.onNext(q.shift());
-              }
+              drainQueue();
               o.onCompleted();
             }
           );
@@ -5414,144 +5632,147 @@
     return new PausableBufferedObservable(this, subject);
   };
 
-  var ControlledObservable = (function (__super__) {
-
-    inherits(ControlledObservable, __super__);
+var ControlledObservable = (function (__super__) {
 
-    function subscribe (observer) {
-      return this.source.subscribe(observer);
-    }
-
-    function ControlledObservable (source, enableQueue, scheduler) {
-      __super__.call(this, subscribe, source);
-      this.subject = new ControlledSubject(enableQueue, scheduler);
-      this.source = source.multicast(this.subject).refCount();
-    }
+  inherits(ControlledObservable, __super__);
 
-    ControlledObservable.prototype.request = function (numberOfItems) {
-      return this.subject.request(numberOfItems == null ? -1 : numberOfItems);
-    };
+  function subscribe (observer) {
+    return this.source.subscribe(observer);
+  }
 
-    return ControlledObservable;
+  function ControlledObservable (source, enableQueue, scheduler) {
+    __super__.call(this, subscribe, source);
+    this.subject = new ControlledSubject(enableQueue, scheduler);
+    this.source = source.multicast(this.subject).refCount();
+  }
 
-  }(Observable));
+  ControlledObservable.prototype.request = function (numberOfItems) {
+    return this.subject.request(numberOfItems == null ? -1 : numberOfItems);
+  };
 
-  var ControlledSubject = (function (__super__) {
+  return ControlledObservable;
 
-    function subscribe (observer) {
-      return this.subject.subscribe(observer);
-    }
+}(Observable));
 
-    inherits(ControlledSubject, __super__);
+var ControlledSubject = (function (__super__) {
 
-    function ControlledSubject(enableQueue, scheduler) {
-      enableQueue == null && (enableQueue = true);
+  function subscribe (observer) {
+    return this.subject.subscribe(observer);
+  }
 
-      __super__.call(this, subscribe);
-      this.subject = new Subject();
-      this.enableQueue = enableQueue;
-      this.queue = enableQueue ? [] : null;
-      this.requestedCount = 0;
-      this.requestedDisposable = disposableEmpty;
-      this.error = null;
-      this.hasFailed = false;
-      this.hasCompleted = false;
-      this.scheduler = scheduler || currentThreadScheduler;
-    }
+  inherits(ControlledSubject, __super__);
+
+  function ControlledSubject(enableQueue, scheduler) {
+    enableQueue == null && (enableQueue = true);
+
+    __super__.call(this, subscribe);
+    this.subject = new Subject();
+    this.enableQueue = enableQueue;
+    this.queue = enableQueue ? [] : null;
+    this.requestedCount = 0;
+    this.requestedDisposable = null;
+    this.error = null;
+    this.hasFailed = false;
+    this.hasCompleted = false;
+    this.scheduler = scheduler || currentThreadScheduler;
+  }
 
-    addProperties(ControlledSubject.prototype, Observer, {
-      onCompleted: function () {
-        this.hasCompleted = true;
-        if (!this.enableQueue || this.queue.length === 0) {
-          this.subject.onCompleted();
-        } else {
-          this.queue.push(Notification.createOnCompleted());
-        }
-      },
-      onError: function (error) {
-        this.hasFailed = true;
-        this.error = error;
-        if (!this.enableQueue || this.queue.length === 0) {
-          this.subject.onError(error);
-        } else {
-          this.queue.push(Notification.createOnError(error));
+  addProperties(ControlledSubject.prototype, Observer, {
+    onCompleted: function () {
+      this.hasCompleted = true;
+      if (!this.enableQueue || this.queue.length === 0) {
+        this.subject.onCompleted();
+        this.disposeCurrentRequest()
+      } else {
+        this.queue.push(Notification.createOnCompleted());
+      }
+    },
+    onError: function (error) {
+      this.hasFailed = true;
+      this.error = error;
+      if (!this.enableQueue || this.queue.length === 0) {
+        this.subject.onError(error);
+        this.disposeCurrentRequest()
+      } else {
+        this.queue.push(Notification.createOnError(error));
+      }
+    },
+    onNext: function (value) {
+      if (this.requestedCount <= 0) {
+        this.enableQueue && this.queue.push(Notification.createOnNext(value));
+      } else {
+        (this.requestedCount-- === 0) && this.disposeCurrentRequest();
+        this.subject.onNext(value);
+      }
+    },
+    _processRequest: function (numberOfItems) {
+      if (this.enableQueue) {
+        while (this.queue.length > 0 && (numberOfItems > 0 || this.queue[0].kind !== 'N')) {
+          var first = this.queue.shift();
+          first.accept(this.subject);
+          if (first.kind === 'N') {
+            numberOfItems--;
+          } else {
+            this.disposeCurrentRequest();
+            this.queue = [];
+          }
         }
-      },
-      onNext: function (value) {
-        var hasRequested = false;
+      }
 
-        if (this.requestedCount === 0) {
-          this.enableQueue && this.queue.push(Notification.createOnNext(value));
-        } else {
-          (this.requestedCount !== -1 && this.requestedCount-- === 0) && this.disposeCurrentRequest();
-          hasRequested = true;
-        }
-        hasRequested && this.subject.onNext(value);
-      },
-      _processRequest: function (numberOfItems) {
-        if (this.enableQueue) {
-          while ((this.queue.length >= numberOfItems && numberOfItems > 0) ||
-          (this.queue.length > 0 && this.queue[0].kind !== 'N')) {
-            var first = this.queue.shift();
-            first.accept(this.subject);
-            if (first.kind === 'N') {
-              numberOfItems--;
-            } else {
-              this.disposeCurrentRequest();
-              this.queue = [];
-            }
-          }
+      return numberOfItems;
+    },
+    request: function (number) {
+      this.disposeCurrentRequest();
+      var self = this;
 
-          return { numberOfItems : numberOfItems, returnValue: this.queue.length !== 0};
-        }
+      this.requestedDisposable = this.scheduler.scheduleWithState(number,
+      function(s, i) {
+        var remaining = self._processRequest(i);
+        var stopped = self.hasCompleted || self.hasFailed
+        if (!stopped && remaining > 0) {
+          self.requestedCount = remaining;
 
-        return { numberOfItems: numberOfItems, returnValue: false };
-      },
-      request: function (number) {
-        this.disposeCurrentRequest();
-        var self = this;
-
-        this.requestedDisposable = this.scheduler.scheduleWithState(number,
-        function(s, i) {
-          var r = self._processRequest(i), remaining = r.numberOfItems;
-          if (!r.returnValue) {
-            self.requestedCount = remaining;
-            self.requestedDisposable = disposableCreate(function () {
-              self.requestedCount = 0;
-            });
-          }
-        });
+          return disposableCreate(function () {
+            self.requestedCount = 0;
+          });
+            // Scheduled item is still in progress. Return a new
+            // disposable to allow the request to be interrupted
+            // via dispose.
+        }
+      });
 
-        return this.requestedDisposable;
-      },
-      disposeCurrentRequest: function () {
+      return this.requestedDisposable;
+    },
+    disposeCurrentRequest: function () {
+      if (this.requestedDisposable) {
         this.requestedDisposable.dispose();
-        this.requestedDisposable = disposableEmpty;
+        this.requestedDisposable = null;
       }
-    });
-
-    return ControlledSubject;
-  }(Observable));
-
-  /**
-   * Attaches a controller to the observable sequence with the ability to queue.
-   * @example
-   * var source = Rx.Observable.interval(100).controlled();
-   * source.request(3); // Reads 3 values
-   * @param {bool} enableQueue truthy value to determine if values should be queued pending the next request
-   * @param {Scheduler} scheduler determines how the requests will be scheduled
-   * @returns {Observable} The observable sequence which is paused based upon the pauser.
-   */
-  observableProto.controlled = function (enableQueue, scheduler) {
-
-    if (enableQueue && isScheduler(enableQueue)) {
-        scheduler = enableQueue;
-        enableQueue = true;
     }
+  });
+
+  return ControlledSubject;
+}(Observable));
+
+/**
+ * Attaches a controller to the observable sequence with the ability to queue.
+ * @example
+ * var source = Rx.Observable.interval(100).controlled();
+ * source.request(3); // Reads 3 values
+ * @param {bool} enableQueue truthy value to determine if values should be queued pending the next request
+ * @param {Scheduler} scheduler determines how the requests will be scheduled
+ * @returns {Observable} The observable sequence which only propagates values on request.
+ */
+observableProto.controlled = function (enableQueue, scheduler) {
+
+  if (enableQueue && isScheduler(enableQueue)) {
+      scheduler = enableQueue;
+      enableQueue = true;
+  }
 
-    if (enableQueue == null) {  enableQueue = true; }
-    return new ControlledObservable(this, enableQueue, scheduler);
-  };
+  if (enableQueue == null) {  enableQueue = true; }
+  return new ControlledObservable(this, enableQueue, scheduler);
+};
 
   /**
    * Pipes the existing Observable sequence into a Node.js Stream.
@@ -5611,11 +5832,8 @@
       var xform = transducer(transformForObserver(o));
       return source.subscribe(
         function(v) {
-          try {
-            xform['@@transducer/step'](o, v);
-          } catch (e) {
-            o.onError(e);
-          }
+          var res = tryCatch(xform['@@transducer/step']).call(xform, o, v);
+          if (res === errorObj) { o.onError(res.e); }
         },
         function (e) { o.onError(e); },
         function() { xform['@@transducer/result'](o); }
@@ -5633,8 +5851,8 @@
     }
 
     function setDisposable(s, state) {
-      var ado = state[0], subscribe = state[1];
-      var sub = tryCatch(subscribe)(ado);
+      var ado = state[0], self = state[1];
+      var sub = tryCatch(self.__subscribe).call(self, ado);
 
       if (sub === errorObj) {
         if(!ado.fail(errorObj.e)) { return thrower(errorObj.e); }
@@ -5642,21 +5860,21 @@
       ado.setDisposable(fixSubscriber(sub));
     }
 
-    function AnonymousObservable(subscribe, parent) {
-      this.source = parent;
-
-      function s(observer) {
-        var ado = new AutoDetachObserver(observer), state = [ado, subscribe];
+    function innerSubscribe(observer) {
+      var ado = new AutoDetachObserver(observer), state = [ado, this];
 
-        if (currentThreadScheduler.scheduleRequired()) {
-          currentThreadScheduler.scheduleWithState(state, setDisposable);
-        } else {
-          setDisposable(null, state);
-        }
-        return ado;
+      if (currentThreadScheduler.scheduleRequired()) {
+        currentThreadScheduler.scheduleWithState(state, setDisposable);
+      } else {
+        setDisposable(null, state);
       }
+      return ado;
+    }
 
-      __super__.call(this, s);
+    function AnonymousObservable(subscribe, parent) {
+      this.source = parent;
+      this.__subscribe = subscribe;
+      __super__.call(this, innerSubscribe);
     }
 
     return AnonymousObservable;