rxjs-rails 2.3.14 → 2.3.20

data/vendor/assets/javascripts/rx.aggregates.js

@@ -46,7 +46,11 @@
     defaultSubComparer = helpers.defaultSubComparer,
     isFunction = helpers.isFunction,
     isPromise = helpers.isPromise,
-    observableFromPromise = Observable.fromPromise;
+    isArrayLike = helpers.isArrayLike,
+    isIterable = helpers.isIterable,
+    observableFromPromise = Observable.fromPromise,
+    observableFrom = Observable.from,
+    deprecate = helpers.deprecate;
 
   // Defaults
   var argumentOutOfRange = 'Argument out of range',
@@ -67,7 +71,7 @@
           observer.onCompleted();
         }
       });
-    });
+    }, source);
   };
 
   function extremaBy(source, keySelector, comparer) {
@@ -102,24 +106,24 @@
         observer.onNext(list);
         observer.onCompleted();
       });
-    });
+    }, source);
   }
 
-    function firstOnly(x) {
-        if (x.length === 0) {
-            throw new Error(sequenceContainsNoElements);
-        }
-        return x[0];
-    }
+  function firstOnly(x) {
+    if (x.length === 0) { throw new Error(sequenceContainsNoElements); }
+    return x[0];
+  }
 
   /**
    * Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
    * For aggregation behavior with incremental intermediate results, see Observable.scan.
+   * @deprecated Use #reduce instead
    * @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 a single element with the final accumulator value.
    */
   observableProto.aggregate = function () {
+    deprecate('aggregate', 'reduce');
     var seed, hasSeed, accumulator;
     if (arguments.length === 2) {
       seed = arguments[0];
@@ -147,28 +151,31 @@
     return hasSeed ? this.scan(seed, accumulator).startWith(seed).finalValue() : this.scan(accumulator).finalValue();
   };
 
-    /**
-     * Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.
-     * @example
-     * var result = source.any();
-     * var result = source.any(function (x) { return x > 3; });
-     * @param {Function} [predicate] A function to test each element for a condition.
-     * @returns {Observable} An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate if given, else if any items are in the sequence.
-     */
-    observableProto.some = observableProto.any = function (predicate, thisArg) {
-        var source = this;
-        return predicate ?
-            source.where(predicate, thisArg).any() :
-            new AnonymousObservable(function (observer) {
-                return source.subscribe(function () {
-                    observer.onNext(true);
-                    observer.onCompleted();
-                }, observer.onError.bind(observer), function () {
-                    observer.onNext(false);
-                    observer.onCompleted();
-                });
-            });
-    };
+  /**
+   * Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.
+   * @param {Function} [predicate] A function to test each element for a condition.
+   * @returns {Observable} An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate if given, else if any items are in the sequence.
+   */
+  observableProto.some = function (predicate, thisArg) {
+    var source = this;
+    return predicate ?
+      source.filter(predicate, thisArg).some() :
+      new AnonymousObservable(function (observer) {
+        return source.subscribe(function () {
+          observer.onNext(true);
+          observer.onCompleted();
+        }, observer.onError.bind(observer), function () {
+          observer.onNext(false);
+          observer.onCompleted();
+        });
+      }, source);
+  };
+
+  /** @deprecated use #some instead */
+  observableProto.any = function () {
+    deprecate('any', 'some');
+    return this.some.apply(this, arguments);
+  };
 
   /**
    * Determines whether an observable sequence is empty.
@@ -178,22 +185,21 @@
     return this.any().map(not);
   };
 
-    /**
-     * Determines whether all elements of an observable sequence satisfy a condition.
-     *
-     * 1 - res = source.all(function (value) { return value.length > 3; });
-     * @memberOf Observable#
-     * @param {Function} [predicate] A function to test each element for a condition.
-     * @param {Any} [thisArg] Object to use as this when executing callback.
-     * @returns {Observable} An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.
-     */
-    observableProto.every = observableProto.all = function (predicate, thisArg) {
-        return this.where(function (v) {
-            return !predicate(v);
-        }, thisArg).any().select(function (b) {
-            return !b;
-        });
-    };
+  /**
+   * Determines whether all elements of an observable sequence satisfy a condition.
+   * @param {Function} [predicate] A function to test each element for a condition.
+   * @param {Any} [thisArg] Object to use as this when executing callback.
+   * @returns {Observable} An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.
+   */
+  observableProto.every = function (predicate, thisArg) {
+    return this.filter(function (v) { return !predicate(v); }, thisArg).some().map(not);
+  };
+
+  /** @deprecated use #every instead */
+  observableProto.all = function () {
+    deprecate('all', 'every');
+    return this.every.apply(this, arguments);
+  };
 
   /**
    * Determines whether an observable sequence contains a specified element with an optional equality comparer.
@@ -226,7 +232,7 @@
           observer.onNext(false);
           observer.onCompleted();
         });
-    });
+    }, this);
   };
 
     /**
@@ -275,13 +281,11 @@
           observer.onNext(-1);
           observer.onCompleted();
         });
-    });
+    }, source);
   };
+
   /**
    * Computes the sum of a sequence of values that are obtained by invoking an optional transform function on each element of the input sequence, else if not specified computes the sum on each item in the sequence.
-   * @example
-   * var res = source.sum();
-   * var res = source.sum(function (x) { return x.value; });
    * @param {Function} [selector] A transform function to apply to each element.
    * @param {Any} [thisArg] Object to use as this when executing callback.
    * @returns {Observable} An observable sequence containing a single element with the sum of the values in the source sequence.
@@ -289,68 +293,62 @@
   observableProto.sum = function (keySelector, thisArg) {
     return keySelector && isFunction(keySelector) ?
       this.map(keySelector, thisArg).sum() :
-      this.aggregate(0, function (prev, curr) {
+      this.reduce(function (prev, curr) {
         return prev + curr;
-      });
+      }, 0);
   };
 
-    /**
-     * Returns the elements in an observable sequence with the minimum key value according to the specified comparer.
-     * @example
-     * var res = source.minBy(function (x) { return x.value; });
-     * var res = source.minBy(function (x) { return x.value; }, function (x, y) { return x - y; });
-     * @param {Function} keySelector Key selector function.
-     * @param {Function} [comparer] Comparer used to compare key values.
-     * @returns {Observable} An observable sequence containing a list of zero or more elements that have a minimum key value.
-     */
-    observableProto.minBy = function (keySelector, comparer) {
-        comparer || (comparer = defaultSubComparer);
-        return extremaBy(this, keySelector, function (x, y) {
-            return comparer(x, y) * -1;
-        });
-    };
+  /**
+   * Returns the elements in an observable sequence with the minimum key value according to the specified comparer.
+   * @example
+   * var res = source.minBy(function (x) { return x.value; });
+   * var res = source.minBy(function (x) { return x.value; }, function (x, y) { return x - y; });
+   * @param {Function} keySelector Key selector function.
+   * @param {Function} [comparer] Comparer used to compare key values.
+   * @returns {Observable} An observable sequence containing a list of zero or more elements that have a minimum key value.
+   */
+  observableProto.minBy = function (keySelector, comparer) {
+    comparer || (comparer = defaultSubComparer);
+    return extremaBy(this, keySelector, function (x, y) { return comparer(x, y) * -1; });
+  };
 
-    /**
-     * Returns the minimum element in an observable sequence according to the optional comparer else a default greater than less than check.
-     * @example
-     * var res = source.min();
-     * var res = source.min(function (x, y) { return x.value - y.value; });
-     * @param {Function} [comparer] Comparer used to compare elements.
-     * @returns {Observable} An observable sequence containing a single element with the minimum element in the source sequence.
-     */
-    observableProto.min = function (comparer) {
-        return this.minBy(identity, comparer).select(function (x) {
-            return firstOnly(x);
-        });
-    };
+  /**
+   * Returns the minimum element in an observable sequence according to the optional comparer else a default greater than less than check.
+   * @example
+   * var res = source.min();
+   * var res = source.min(function (x, y) { return x.value - y.value; });
+   * @param {Function} [comparer] Comparer used to compare elements.
+   * @returns {Observable} An observable sequence containing a single element with the minimum element in the source sequence.
+   */
+  observableProto.min = function (comparer) {
+    return this.minBy(identity, comparer).map(function (x) { return firstOnly(x); });
+  };
 
-    /**
-     * Returns the elements in an observable sequence with the maximum  key value according to the specified comparer.
-     * @example
-     * var res = source.maxBy(function (x) { return x.value; });
-     * var res = source.maxBy(function (x) { return x.value; }, function (x, y) { return x - y;; });
-     * @param {Function} keySelector Key selector function.
-     * @param {Function} [comparer]  Comparer used to compare key values.
-     * @returns {Observable} An observable sequence containing a list of zero or more elements that have a maximum key value.
-     */
-    observableProto.maxBy = function (keySelector, comparer) {
-        comparer || (comparer = defaultSubComparer);
-        return extremaBy(this, keySelector, comparer);
-    };
+  /**
+   * Returns the elements in an observable sequence with the maximum  key value according to the specified comparer.
+   * @example
+   * var res = source.maxBy(function (x) { return x.value; });
+   * var res = source.maxBy(function (x) { return x.value; }, function (x, y) { return x - y;; });
+   * @param {Function} keySelector Key selector function.
+   * @param {Function} [comparer]  Comparer used to compare key values.
+   * @returns {Observable} An observable sequence containing a list of zero or more elements that have a maximum key value.
+   */
+  observableProto.maxBy = function (keySelector, comparer) {
+    comparer || (comparer = defaultSubComparer);
+    return extremaBy(this, keySelector, comparer);
+  };
 
-    /**
-     * Returns the maximum value in an observable sequence according to the specified comparer.
-     * @example
-     * var res = source.max();
-     * var res = source.max(function (x, y) { return x.value - y.value; });
-     * @param {Function} [comparer] Comparer used to compare elements.
-     * @returns {Observable} An observable sequence containing a single element with the maximum element in the source sequence.
-     */
-    observableProto.max = function (comparer) {
-        return this.maxBy(identity, comparer).select(function (x) {
-            return firstOnly(x);
-        });
-    };
+  /**
+   * Returns the maximum value in an observable sequence according to the specified comparer.
+   * @example
+   * var res = source.max();
+   * var res = source.max(function (x, y) { return x.value - y.value; });
+   * @param {Function} [comparer] Comparer used to compare elements.
+   * @returns {Observable} An observable sequence containing a single element with the maximum element in the source sequence.
+   */
+  observableProto.max = function (comparer) {
+    return this.maxBy(identity, comparer).map(function (x) { return firstOnly(x); });
+  };
 
   /**
    * Computes the average of an observable sequence of values that are in the sequence or obtained by invoking a transform function on each element of the input sequence if present.
@@ -374,28 +372,6 @@
       });
   };
 
-  function sequenceEqualArray(first, second, comparer) {
-    return new AnonymousObservable(function (observer) {
-      var count = 0, len = second.length;
-      return first.subscribe(function (value) {
-        var equal = false;
-        try {
-          count < len && (equal = comparer(value, second[count++]));
-        } catch (e) {
-          observer.onError(e);
-          return;
-        }
-        if (!equal) {
-          observer.onNext(false);
-          observer.onCompleted();
-        }
-      }, observer.onError.bind(observer), function () {
-        observer.onNext(count === len);
-        observer.onCompleted();
-      });
-    });
-  }
-
   /**
    *  Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer.
    *
@@ -411,9 +387,6 @@
   observableProto.sequenceEqual = function (second, comparer) {
     var first = this;
     comparer || (comparer = defaultComparer);
-    if (Array.isArray(second)) {
-      return sequenceEqualArray(first, second, comparer);
-    }
     return new AnonymousObservable(function (observer) {
       var donel = false, doner = false, ql = [], qr = [];
       var subscription1 = first.subscribe(function (x) {
@@ -449,6 +422,7 @@
         }
       });
 
+      (isArrayLike(second) || isIterable(second)) && (second = observableFrom(second));
       isPromise(second) && (second = observableFromPromise(second));
       var subscription2 = second.subscribe(function (x) {
         var equal;
@@ -483,55 +457,52 @@
         }
       });
       return new CompositeDisposable(subscription1, subscription2);
-    });
+    }, first);
   };
 
-    function elementAtOrDefault(source, index, hasDefault, defaultValue) {
-        if (index < 0) {
-            throw new Error(argumentOutOfRange);
+  function elementAtOrDefault(source, index, hasDefault, defaultValue) {
+    if (index < 0) { throw new Error(argumentOutOfRange); }
+    return new AnonymousObservable(function (observer) {
+      var i = index;
+      return source.subscribe(function (x) {
+        if (i-- === 0) {
+          observer.onNext(x);
+          observer.onCompleted();
         }
-        return new AnonymousObservable(function (observer) {
-            var i = index;
-            return source.subscribe(function (x) {
-                if (i === 0) {
-                    observer.onNext(x);
-                    observer.onCompleted();
-                }
-                i--;
-            }, observer.onError.bind(observer), function () {
-                if (!hasDefault) {
-                    observer.onError(new Error(argumentOutOfRange));
-                } else {
-                    observer.onNext(defaultValue);
-                    observer.onCompleted();
-                }
-            });
-        });
-    }
+      }, observer.onError.bind(observer), function () {
+        if (!hasDefault) {
+          observer.onError(new Error(argumentOutOfRange));
+        } else {
+          observer.onNext(defaultValue);
+          observer.onCompleted();
+        }
+      });
+    }, source);
+  }
 
-    /**
-     * Returns the element at a specified index in a sequence.
-     * @example
-     * var res = source.elementAt(5);
-     * @param {Number} index The zero-based index of the element to retrieve.
-     * @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence.
-     */
-    observableProto.elementAt =  function (index) {
-        return elementAtOrDefault(this, index, false);
-    };
+  /**
+   * Returns the element at a specified index in a sequence.
+   * @example
+   * var res = source.elementAt(5);
+   * @param {Number} index The zero-based index of the element to retrieve.
+   * @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence.
+   */
+  observableProto.elementAt =  function (index) {
+    return elementAtOrDefault(this, index, false);
+  };
 
-    /**
-     * Returns the element at a specified index in a sequence or a default value if the index is out of range.
-     * @example
-     * var res = source.elementAtOrDefault(5);
-     * var res = source.elementAtOrDefault(5, 0);
-     * @param {Number} index The zero-based index of the element to retrieve.
-     * @param [defaultValue] The default value if the index is outside the bounds of the source sequence.
-     * @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence.
-     */
-    observableProto.elementAtOrDefault = function (index, defaultValue) {
-        return elementAtOrDefault(this, index, true, defaultValue);
-    };
+  /**
+   * Returns the element at a specified index in a sequence or a default value if the index is out of range.
+   * @example
+   * var res = source.elementAtOrDefault(5);
+   * var res = source.elementAtOrDefault(5, 0);
+   * @param {Number} index The zero-based index of the element to retrieve.
+   * @param [defaultValue] The default value if the index is outside the bounds of the source sequence.
+   * @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence.
+   */
+  observableProto.elementAtOrDefault = function (index, defaultValue) {
+    return elementAtOrDefault(this, index, true, defaultValue);
+  };
 
   function singleOrDefaultAsync(source, hasDefault, defaultValue) {
     return new AnonymousObservable(function (observer) {
@@ -551,14 +522,11 @@
           observer.onCompleted();
         }
       });
-    });
+    }, source);
   }
 
   /**
    * Returns the only element of an observable sequence that satisfies the condition in the optional predicate, and reports an exception if there is not exactly one element in the observable sequence.
-   * @example
-   * var res = res = source.single();
-   * var res = res = source.single(function (x) { return x === 42; });
    * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
    * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
    * @returns {Observable} Sequence containing the single element in the observable sequence that satisfies the condition in the predicate.
@@ -588,211 +556,198 @@
       singleOrDefaultAsync(this, true, defaultValue);
   };
 
-    function firstOrDefaultAsync(source, hasDefault, defaultValue) {
-        return new AnonymousObservable(function (observer) {
-            return source.subscribe(function (x) {
-                observer.onNext(x);
-                observer.onCompleted();
-            }, observer.onError.bind(observer), function () {
-                if (!hasDefault) {
-                    observer.onError(new Error(sequenceContainsNoElements));
-                } else {
-                    observer.onNext(defaultValue);
-                    observer.onCompleted();
-                }
-            });
-        });
-    }
+  function firstOrDefaultAsync(source, hasDefault, defaultValue) {
+    return new AnonymousObservable(function (observer) {
+      return source.subscribe(function (x) {
+        observer.onNext(x);
+        observer.onCompleted();
+      }, observer.onError.bind(observer), function () {
+        if (!hasDefault) {
+          observer.onError(new Error(sequenceContainsNoElements));
+        } else {
+          observer.onNext(defaultValue);
+          observer.onCompleted();
+        }
+      });
+    }, source);
+  }
 
-    /**
-     * Returns the first element of an observable sequence that satisfies the condition in the predicate if present else the first item in the sequence.
-     * @example
-     * var res = res = source.first();
-     * var res = res = source.first(function (x) { return x > 3; });
-     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
-     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
-     * @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate if provided, else the first item in the sequence.
-     */
-    observableProto.first = function (predicate, thisArg) {
-        return predicate ?
-            this.where(predicate, thisArg).first() :
-            firstOrDefaultAsync(this, false);
-    };
+  /**
+   * Returns the first element of an observable sequence that satisfies the condition in the predicate if present else the first item in the sequence.
+   * @example
+   * var res = res = source.first();
+   * var res = res = source.first(function (x) { return x > 3; });
+   * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+   * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+   * @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate if provided, else the first item in the sequence.
+   */
+  observableProto.first = function (predicate, thisArg) {
+    return predicate ?
+      this.where(predicate, thisArg).first() :
+      firstOrDefaultAsync(this, false);
+  };
 
-    /**
-     * Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
-     * @example
-     * var res = res = source.firstOrDefault();
-     * var res = res = source.firstOrDefault(function (x) { return x > 3; });
-     * var res = source.firstOrDefault(function (x) { return x > 3; }, 0);
-     * var res = source.firstOrDefault(null, 0);
-     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
-     * @param {Any} [defaultValue] The default value if no such element exists.  If not specified, defaults to null.
-     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
-     * @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
-     */
-    observableProto.firstOrDefault = function (predicate, defaultValue, thisArg) {
-        return predicate ?
-            this.where(predicate).firstOrDefault(null, defaultValue) :
-            firstOrDefaultAsync(this, true, defaultValue);
-    };
+  /**
+   * Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+   * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+   * @param {Any} [defaultValue] The default value if no such element exists.  If not specified, defaults to null.
+   * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+   * @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+   */
+  observableProto.firstOrDefault = function (predicate, defaultValue, thisArg) {
+    return predicate ?
+      this.where(predicate).firstOrDefault(null, defaultValue) :
+      firstOrDefaultAsync(this, true, defaultValue);
+  };
 
-    function lastOrDefaultAsync(source, hasDefault, defaultValue) {
-        return new AnonymousObservable(function (observer) {
-            var value = defaultValue, seenValue = false;
-            return source.subscribe(function (x) {
-                value = x;
-                seenValue = true;
-            }, observer.onError.bind(observer), function () {
-                if (!seenValue && !hasDefault) {
-                    observer.onError(new Error(sequenceContainsNoElements));
-                } else {
-                    observer.onNext(value);
-                    observer.onCompleted();
-                }
-            });
-        });
-    }
+  function lastOrDefaultAsync(source, hasDefault, defaultValue) {
+    return new AnonymousObservable(function (observer) {
+      var value = defaultValue, seenValue = false;
+      return source.subscribe(function (x) {
+        value = x;
+        seenValue = true;
+      }, observer.onError.bind(observer), function () {
+        if (!seenValue && !hasDefault) {
+          observer.onError(new Error(sequenceContainsNoElements));
+        } else {
+          observer.onNext(value);
+          observer.onCompleted();
+        }
+      });
+    }, source);
+  }
 
-    /**
-     * Returns the last element of an observable sequence that satisfies the condition in the predicate if specified, else the last element.
-     * @example
-     * var res = source.last();
-     * var res = source.last(function (x) { return x > 3; });
-     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
-     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
-     * @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate.
-     */
-    observableProto.last = function (predicate, thisArg) {
-        return predicate ?
-            this.where(predicate, thisArg).last() :
-            lastOrDefaultAsync(this, false);
-    };
+  /**
+   * Returns the last element of an observable sequence that satisfies the condition in the predicate if specified, else the last element.
+   * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+   * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+   * @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate.
+   */
+  observableProto.last = function (predicate, thisArg) {
+    return predicate ?
+      this.where(predicate, thisArg).last() :
+      lastOrDefaultAsync(this, false);
+  };
 
-    /**
-     * Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
-     * @example
-     * var res = source.lastOrDefault();
-     * var res = source.lastOrDefault(function (x) { return x > 3; });
-     * var res = source.lastOrDefault(function (x) { return x > 3; }, 0);
-     * var res = source.lastOrDefault(null, 0);
-     * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
-     * @param [defaultValue] The default value if no such element exists.  If not specified, defaults to null.
-     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
-     * @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
-     */
-    observableProto.lastOrDefault = function (predicate, defaultValue, thisArg) {
-        return predicate ?
-            this.where(predicate, thisArg).lastOrDefault(null, defaultValue) :
-            lastOrDefaultAsync(this, true, defaultValue);
-    };
+  /**
+   * Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+   * @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
+   * @param [defaultValue] The default value if no such element exists.  If not specified, defaults to null.
+   * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+   * @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
+   */
+  observableProto.lastOrDefault = function (predicate, defaultValue, thisArg) {
+    return predicate ?
+      this.where(predicate, thisArg).lastOrDefault(null, defaultValue) :
+      lastOrDefaultAsync(this, true, defaultValue);
+  };
 
-    function findValue (source, predicate, thisArg, yieldIndex) {
-        return new AnonymousObservable(function (observer) {
-            var i = 0;
-            return source.subscribe(function (x) {
-                var shouldRun;
-                try {
-                    shouldRun = predicate.call(thisArg, x, i, source);
-                } catch(e) {
-                    observer.onError(e);
-                    return;
-                }
-                if (shouldRun) {
-                    observer.onNext(yieldIndex ? i : x);
-                    observer.onCompleted();
-                } else {
-                    i++;
-                }
-            }, observer.onError.bind(observer), function () {
-                observer.onNext(yieldIndex ? -1 : undefined);
-                observer.onCompleted();
-            });
-        });
-    }
+  function findValue (source, predicate, thisArg, yieldIndex) {
+    return new AnonymousObservable(function (observer) {
+      var i = 0;
+      return source.subscribe(function (x) {
+        var shouldRun;
+        try {
+          shouldRun = predicate.call(thisArg, x, i, source);
+        } catch (e) {
+          observer.onError(e);
+          return;
+        }
+        if (shouldRun) {
+          observer.onNext(yieldIndex ? i : x);
+          observer.onCompleted();
+        } else {
+          i++;
+        }
+      }, observer.onError.bind(observer), function () {
+        observer.onNext(yieldIndex ? -1 : undefined);
+        observer.onCompleted();
+      });
+    }, source);
+  }
 
-    /**
-     * Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Observable sequence.
-     * @param {Function} predicate The predicate that defines the conditions of the element to search for.
-     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
-     * @returns {Observable} An Observable sequence with the first element that matches the conditions defined by the specified predicate, if found; otherwise, undefined.
-     */
-    observableProto.find = function (predicate, thisArg) {
-        return findValue(this, predicate, thisArg, false);
-    };
+  /**
+   * Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Observable sequence.
+   * @param {Function} predicate The predicate that defines the conditions of the element to search for.
+   * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+   * @returns {Observable} An Observable sequence with the first element that matches the conditions defined by the specified predicate, if found; otherwise, undefined.
+   */
+  observableProto.find = function (predicate, thisArg) {
+    return findValue(this, predicate, thisArg, false);
+  };
 
-    /**
-     * Searches for an element that matches the conditions defined by the specified predicate, and returns
-     * an Observable sequence with the zero-based index of the first occurrence within the entire Observable sequence.
-     * @param {Function} predicate The predicate that defines the conditions of the element to search for.
-     * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
-     * @returns {Observable} An Observable sequence with the zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1.
-    */
-    observableProto.findIndex = function (predicate, thisArg) {
-        return findValue(this, predicate, thisArg, true);
-    };
+  /**
+   * Searches for an element that matches the conditions defined by the specified predicate, and returns
+   * an Observable sequence with the zero-based index of the first occurrence within the entire Observable sequence.
+   * @param {Function} predicate The predicate that defines the conditions of the element to search for.
+   * @param {Any} [thisArg] Object to use as `this` when executing the predicate.
+   * @returns {Observable} An Observable sequence with the zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1.
+  */
+  observableProto.findIndex = function (predicate, thisArg) {
+    return findValue(this, predicate, thisArg, true);
+  };
 
-  if (!!root.Set) {
-    /**
-     * Converts the observable sequence to a Set if it exists.
-     * @returns {Observable} An observable sequence with a single value of a Set containing the values from the observable sequence.
-     */
-    observableProto.toSet = function () {
-      var source = this;
-      return new AnonymousObservable(function (observer) {
-        var s = new root.Set();
-        return source.subscribe(
-          s.add.bind(s),
-          observer.onError.bind(observer),
-          function () {
-            observer.onNext(s);
-            observer.onCompleted();
-          });
-      });
-    };
-  }
 
-  if (!!root.Map) {
-    /**
-    * Converts the observable sequence to a Map if it exists.
-    * @param {Function} keySelector A function which produces the key for the Map.
-    * @param {Function} [elementSelector] An optional function which produces the element for the Map. If not present, defaults to the value from the observable sequence.
-    * @returns {Observable} An observable sequence with a single value of a Map containing the values from the observable sequence.
-    */
-    observableProto.toMap = function (keySelector, elementSelector) {
-      var source = this;
-      return new AnonymousObservable(function (observer) {
-        var m = new root.Map();
-        return source.subscribe(
-          function (x) {
-            var key;
+  /**
+   * Converts the observable sequence to a Set if it exists.
+   * @returns {Observable} An observable sequence with a single value of a Set containing the values from the observable sequence.
+   */
+  observableProto.toSet = function () {
+    if (typeof root.Set === 'undefined') { throw new TypeError(); }
+    var source = this;
+    return new AnonymousObservable(function (observer) {
+      var s = new root.Set();
+      return source.subscribe(
+        s.add.bind(s),
+        observer.onError.bind(observer),
+        function () {
+          observer.onNext(s);
+          observer.onCompleted();
+        });
+    }, source);
+  };
+
+
+  /**
+  * Converts the observable sequence to a Map if it exists.
+  * @param {Function} keySelector A function which produces the key for the Map.
+  * @param {Function} [elementSelector] An optional function which produces the element for the Map. If not present, defaults to the value from the observable sequence.
+  * @returns {Observable} An observable sequence with a single value of a Map containing the values from the observable sequence.
+  */
+  observableProto.toMap = function (keySelector, elementSelector) {
+    if (typeof root.Map === 'undefined') { throw new TypeError(); }
+    var source = this;
+    return new AnonymousObservable(function (observer) {
+      var m = new root.Map();
+      return source.subscribe(
+        function (x) {
+          var key;
+          try {
+            key = keySelector(x);
+          } catch (e) {
+            observer.onError(e);
+            return;
+          }
+
+          var element = x;
+          if (elementSelector) {
             try {
-              key = keySelector(x);
+              element = elementSelector(x);
             } catch (e) {
               observer.onError(e);
               return;
             }
+          }
 
-            var element = x;
-            if (elementSelector) {
-              try {
-                element = elementSelector(x);
-              } catch (e) {
-                observer.onError(e);
-                return;
-              }
-            }
-
-            m.set(key, element);
-          },
-          observer.onError.bind(observer),
-          function () {
-            observer.onNext(m);
-            observer.onCompleted();
-          });
-      });
-    };
-  }
+          m.set(key, element);
+        },
+        observer.onError.bind(observer),
+        function () {
+          observer.onNext(m);
+          observer.onCompleted();
+        });
+    }, source);
+  };
 
     return Rx;
 }));