feat(partition): add higher-order lettable version of partition

src/operator/partition.ts

@@ -1,7 +1,5 @@
-import { not } from '../util/not';
-import { filter } from './filter';
 import { Observable } from '../Observable';
-
+import { partition as higherOrder } from '../operators/partition';
 /**
  * Splits the source Observable into two, one with values that satisfy a
  * predicate, and another with values that don't satisfy the predicate.
@@ -44,8 +42,5 @@ import { Observable } from '../Observable';
  * @owner Observable
  */
 export function partition<T>(this: Observable<T>, predicate: (value: T) => boolean, thisArg?: any): [Observable<T>, Observable<T>] {
-  return [
-    filter.call(this, predicate, thisArg),
-    filter.call(this, not(predicate, thisArg))
-  ];
+  return higherOrder(predicate, thisArg)(this);
 }

src/operators/index.ts

@@ -47,6 +47,7 @@ export { multicast } from './multicast';
 export { observeOn } from './observeOn';
 export { onErrorResumeNext } from './onErrorResumeNext';
 export { pairwise } from './pairwise';
+export { partition } from './partition';
 export { publish } from './publish';
 export { race } from './race';
 export { reduce } from './reduce';

src/operators/partition.ts

@@ -0,0 +1,52 @@
+import { not } from '../util/not';
+import { filter } from './filter';
+import { Observable } from '../Observable';
+import { UnaryFunction } from '../interfaces';
+
+/**
+ * Splits the source Observable into two, one with values that satisfy a
+ * predicate, and another with values that don't satisfy the predicate.
+ *
+ * <span class="informal">It's like {@link filter}, but returns two Observables:
+ * one like the output of {@link filter}, and the other with values that did not
+ * pass the condition.</span>
+ *
+ * <img src="./img/partition.png" width="100%">
+ *
+ * `partition` outputs an array with two Observables that partition the values
+ * from the source Observable through the given `predicate` function. The first
+ * Observable in that array emits source values for which the predicate argument
+ * returns true. The second Observable emits source values for which the
+ * predicate returns false. The first behaves like {@link filter} and the second
+ * behaves like {@link filter} with the predicate negated.
+ *
+ * @example <caption>Partition click events into those on DIV elements and those elsewhere</caption>
+ * var clicks = Rx.Observable.fromEvent(document, 'click');
+ * var parts = clicks.partition(ev => ev.target.tagName === 'DIV');
+ * var clicksOnDivs = parts[0];
+ * var clicksElsewhere = parts[1];
+ * clicksOnDivs.subscribe(x => console.log('DIV clicked: ', x));
+ * clicksElsewhere.subscribe(x => console.log('Other clicked: ', x));
+ *
+ * @see {@link filter}
+ *
+ * @param {function(value: T, index: number): boolean} predicate A function that
+ * evaluates each value emitted by the source Observable. If it returns `true`,
+ * the value is emitted on the first Observable in the returned array, if
+ * `false` the value is emitted on the second Observable in the array. The
+ * `index` parameter is the number `i` for the i-th source emission that has
+ * happened since the subscription, starting from the number `0`.
+ * @param {any} [thisArg] An optional argument to determine the value of `this`
+ * in the `predicate` function.
+ * @return {[Observable<T>, Observable<T>]} An array with two Observables: one
+ * with values that passed the predicate, and another with values that did not
+ * pass the predicate.
+ * @method partition
+ * @owner Observable
+ */
+export function partition<T>(predicate: (value: T) => boolean, thisArg?: any): UnaryFunction<Observable<T>, [Observable<T>, Observable<T>]> {
+  return (source: Observable<T>) => [
+    filter(predicate, thisArg)(source),
+    filter(not(predicate, thisArg) as any)(source)
+  ];
+}