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

src/operator/mapTo.ts

@@ -1,6 +1,5 @@
-import { Operator } from '../Operator';
-import { Subscriber } from '../Subscriber';
 import { Observable } from '../Observable';
+import { mapTo as higherOrder } from '../operators';
 
 /**
  * Emits the given constant value on the output Observable every time the source
@@ -29,37 +28,5 @@ import { Observable } from '../Observable';
  * @owner Observable
  */
 export function mapTo<T, R>(this: Observable<T>, value: R): Observable<R> {
-  return this.lift(new MapToOperator(value));
-}
-
-class MapToOperator<T, R> implements Operator<T, R> {
-
-  value: R;
-
-  constructor(value: R) {
-    this.value = value;
-  }
-
-  call(subscriber: Subscriber<R>, source: any): any {
-    return source.subscribe(new MapToSubscriber(subscriber, this.value));
-  }
-}
-
-/**
- * We need this JSDoc comment for affecting ESDoc.
- * @ignore
- * @extends {Ignored}
- */
-class MapToSubscriber<T, R> extends Subscriber<T> {
-
-  value: R;
-
-  constructor(destination: Subscriber<R>, value: R) {
-    super(destination);
-    this.value = value;
-  }
-
-  protected _next(x: T) {
-    this.destination.next(this.value);
-  }
+  return higherOrder(value)(this);
 }

src/operators/index.ts

@@ -34,6 +34,7 @@ export { ignoreElements } from './ignoreElements';
 export { isEmpty } from './isEmpty';
 export { last } from './last';
 export { map } from './map';
+export { mapTo } from './mapTo';
 export { materialize } from './materialize';
 export { max } from './max';
 export { merge } from './merge';

src/operators/mapTo.ts

@@ -0,0 +1,66 @@
+import { Operator } from '../Operator';
+import { Subscriber } from '../Subscriber';
+import { Observable } from '../Observable';
+import { OperatorFunction } from '../interfaces';
+
+/**
+ * Emits the given constant value on the output Observable every time the source
+ * Observable emits a value.
+ *
+ * <span class="informal">Like {@link map}, but it maps every source value to
+ * the same output value every time.</span>
+ *
+ * <img src="./img/mapTo.png" width="100%">
+ *
+ * Takes a constant `value` as argument, and emits that whenever the source
+ * Observable emits a value. In other words, ignores the actual source value,
+ * and simply uses the emission moment to know when to emit the given `value`.
+ *
+ * @example <caption>Map every click to the string 'Hi'</caption>
+ * var clicks = Rx.Observable.fromEvent(document, 'click');
+ * var greetings = clicks.mapTo('Hi');
+ * greetings.subscribe(x => console.log(x));
+ *
+ * @see {@link map}
+ *
+ * @param {any} value The value to map each source value to.
+ * @return {Observable} An Observable that emits the given `value` every time
+ * the source Observable emits something.
+ * @method mapTo
+ * @owner Observable
+ */
+export function mapTo<T, R>(value: R): OperatorFunction<T, R> {
+  return (source: Observable<T>) => source.lift(new MapToOperator(value));
+}
+
+class MapToOperator<T, R> implements Operator<T, R> {
+
+  value: R;
+
+  constructor(value: R) {
+    this.value = value;
+  }
+
+  call(subscriber: Subscriber<R>, source: any): any {
+    return source.subscribe(new MapToSubscriber(subscriber, this.value));
+  }
+}
+
+/**
+ * We need this JSDoc comment for affecting ESDoc.
+ * @ignore
+ * @extends {Ignored}
+ */
+class MapToSubscriber<T, R> extends Subscriber<T> {
+
+  value: R;
+
+  constructor(destination: Subscriber<R>, value: R) {
+    super(destination);
+    this.value = value;
+  }
+
+  protected _next(x: T) {
+    this.destination.next(this.value);
+  }
+}