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

ReactiveX · Sep 6, 2017 · 3bc050a · 3bc050a
1 parent e8be197
commit 3bc050a
Show file tree

Hide file tree

Showing 3 changed files with 98 additions and 73 deletions.
diff --git a/src/operator/single.ts b/src/operator/single.ts
@@ -1,9 +1,5 @@
 import { Observable } from '../Observable';
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
-import { Observer } from '../Observer';
-import { EmptyError } from '../util/EmptyError';
-import { TeardownLogic } from '../Subscription';
+import { single as higherOrder } from '../operators/single';
 
 /**
  * Returns an Observable that emits the single item emitted by the source Observable that matches a specified
@@ -22,72 +18,5 @@ import { TeardownLogic } from '../Subscription';
  * @owner Observable
  */
 export function single<T>(this: Observable<T>, predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<T> {
-  return this.lift(new SingleOperator(predicate, this));
-}
-
-class SingleOperator<T> implements Operator<T, T> {
-  constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-              private source?: Observable<T>) {
-  }
-
-  call(subscriber: Subscriber<T>, source: any): TeardownLogic {
-    return source.subscribe(new SingleSubscriber(subscriber, this.predicate, this.source));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-class SingleSubscriber<T> extends Subscriber<T> {
-  private seenValue: boolean = false;
-  private singleValue: T;
-  private index: number = 0;
-
-  constructor(destination: Observer<T>,
-              private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-              private source?: Observable<T>) {
-    super(destination);
-  }
-
-  private applySingleValue(value: T): void {
-    if (this.seenValue) {
-      this.destination.error('Sequence contains more than one element');
-    } else {
-      this.seenValue = true;
-      this.singleValue = value;
-    }
-  }
-
-  protected _next(value: T): void {
-    const index = this.index++;
-
-    if (this.predicate) {
-      this.tryNext(value, index);
-    } else {
-      this.applySingleValue(value);
-    }
-  }
-
-  private tryNext(value: T, index: number): void {
-    try {
-      if (this.predicate(value, index, this.source)) {
-        this.applySingleValue(value);
-      }
-    } catch (err) {
-      this.destination.error(err);
-    }
-  }
-
-  protected _complete(): void {
-    const destination = this.destination;
-
-    if (this.index > 0) {
-      destination.next(this.seenValue ? this.singleValue : undefined);
-      destination.complete();
-    } else {
-      destination.error(new EmptyError);
-    }
-  }
+  return higherOrder(predicate)(this);
 }
diff --git a/src/operators/index.ts b/src/operators/index.ts
@@ -64,6 +64,7 @@ export { scan } from './scan';
 export { sequenceEqual } from './sequenceEqual';
 export { share } from './share';
 export { shareReplay } from './shareReplay';
+export { single } from './single';
 export { subscribeOn } from './subscribeOn';
 export { switchAll } from './switchAll';
 export { switchMap } from './switchMap';

diff --git a/src/operators/single.ts b/src/operators/single.ts
@@ -0,0 +1,95 @@
+import { Observable } from '../Observable';
+import { Operator } from '../Operator';
+import { Subscriber } from '../Subscriber';
+import { Observer } from '../Observer';
+import { EmptyError } from '../util/EmptyError';
+import { TeardownLogic } from '../Subscription';
+
+import { MonoTypeOperatorFunction } from '../interfaces';
+
+/**
+ * Returns an Observable that emits the single item emitted by the source Observable that matches a specified
+ * predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no
+ * such items, notify of an IllegalArgumentException or NoSuchElementException respectively.
+ *
+ * <img src="./img/single.png" width="100%">
+ *
+ * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`
+ * callback if the Observable completes before any `next` notification was sent.
+ * @param {Function} predicate - A predicate function to evaluate items emitted by the source Observable.
+ * @return {Observable<T>} An Observable that emits the single item emitted by the source Observable that matches
+ * the predicate.
+ .
+ * @method single
+ * @owner Observable
+ */
+export function single<T>(predicate?: (value: T, index: number, source: Observable<T>) => boolean): MonoTypeOperatorFunction<T> {
+  return (source: Observable<T>) => source.lift(new SingleOperator(predicate, source));
+}
+
+class SingleOperator<T> implements Operator<T, T> {
+  constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
+              private source?: Observable<T>) {
+  }
+
+  call(subscriber: Subscriber<T>, source: any): TeardownLogic {
+    return source.subscribe(new SingleSubscriber(subscriber, this.predicate, this.source));
+  }
+}
+
+/**
+ * We need this JSDoc comment for affecting ESDoc.
+ * @ignore
+ * @extends {Ignored}
+ */
+class SingleSubscriber<T> extends Subscriber<T> {
+  private seenValue: boolean = false;
+  private singleValue: T;
+  private index: number = 0;
+
+  constructor(destination: Observer<T>,
+              private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
+              private source?: Observable<T>) {
+    super(destination);
+  }
+
+  private applySingleValue(value: T): void {
+    if (this.seenValue) {
+      this.destination.error('Sequence contains more than one element');
+    } else {
+      this.seenValue = true;
+      this.singleValue = value;
+    }
+  }
+
+  protected _next(value: T): void {
+    const index = this.index++;
+
+    if (this.predicate) {
+      this.tryNext(value, index);
+    } else {
+      this.applySingleValue(value);
+    }
+  }
+
+  private tryNext(value: T, index: number): void {
+    try {
+      if (this.predicate(value, index, this.source)) {
+        this.applySingleValue(value);
+      }
+    } catch (err) {
+      this.destination.error(err);
+    }
+  }
+
+  protected _complete(): void {
+    const destination = this.destination;
+
+    if (this.index > 0) {
+      destination.next(this.seenValue ? this.singleValue : undefined);
+      destination.complete();
+    } else {
+      destination.error(new EmptyError);
+    }
+  }
+}