feat(publish): add higher-order lettable variant of publish

src/operator/publish.ts

@@ -1,7 +1,7 @@
-import { Subject } from '../Subject';
+
 import { Observable } from '../Observable';
-import { multicast } from './multicast';
 import { ConnectableObservable } from '../observable/ConnectableObservable';
+import { publish as higherOrder } from '../operators';
 
 /* tslint:disable:max-line-length */
 export function publish<T>(this: Observable<T>): ConnectableObservable<T>;
@@ -22,8 +22,7 @@ export function publish<T>(this: Observable<T>, selector: selector<T>): Observab
  * @owner Observable
  */
 export function publish<T>(this: Observable<T>, selector?: (source: Observable<T>) => Observable<T>): Observable<T> | ConnectableObservable<T> {
-  return selector ? multicast.call(this, () => new Subject<T>(), selector) :
-                    multicast.call(this, new Subject<T>());
+  return higherOrder(selector)(this);
 }
 
 export type selector<T> = (source: Observable<T>) => Observable<T>;

src/operators/index.ts

@@ -6,6 +6,7 @@ export { max } from './max';
 export { mergeMap } from './mergeMap';
 export { min } from './min';
 export { multicast } from './multicast';
+export { publish } from './publish';
 export { reduce } from './reduce';
 export { scan } from './scan';
 export { switchMap } from './switchMap';

src/operators/publish.ts

@@ -0,0 +1,27 @@
+import { Subject } from '../Subject';
+import { multicast } from './multicast';
+import { MonoTypeOperatorFunction } from '../interfaces';
+
+/* tslint:disable:max-line-length */
+export function publish<T>(): MonoTypeOperatorFunction<T>;
+export function publish<T>(selector: MonoTypeOperatorFunction<T>): MonoTypeOperatorFunction<T>;
+/* tslint:enable:max-line-length */
+
+/**
+ * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
+ * before it begins emitting items to those Observers that have subscribed to it.
+ *
+ * <img src="./img/publish.png" width="100%">
+ *
+ * @param {Function} [selector] - Optional selector function which can use the multicasted source sequence as many times
+ * as needed, without causing multiple subscriptions to the source sequence.
+ * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
+ * @return A ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.
+ * @method publish
+ * @owner Observable
+ */
+export function publish<T>(selector?: MonoTypeOperatorFunction<T>): MonoTypeOperatorFunction<T> {
+  return selector ?
+    multicast(() => new Subject<T>(), selector) :
+    multicast(new Subject<T>());
+}