From 19337741c435c6e3a24f5dbeb46d6671632bd1d4 Mon Sep 17 00:00:00 2001
From: David Driscoll <david.driscoll@gmail.com>
Date: Sat, 13 Feb 2016 21:49:40 -0500
Subject: [PATCH] chore(typings): added type signatures for
 concat/exhaust/merge/switch

also adds signatures for the "All", "Map", and "MapTo" variants.
---
 src/CoreOperators.ts                          | 55 +++++++++++--------
 src/Observable.ts                             | 54 ++++++++++--------
 src/Rx.KitchenSink.ts                         |  7 ++-
 src/add/operator/mergeMap.ts                  |  4 +-
 src/add/operator/mergeMapTo.ts                |  2 +-
 src/observable/BoundNodeCallbackObservable.ts |  2 +-
 src/observable/FromObservable.ts              |  6 +-
 src/observable/dom/WebSocketSubject.ts        |  2 +-
 src/operator/combineAll.ts                    |  7 ++-
 src/operator/concat.ts                        | 33 +++++++++--
 src/operator/concatAll.ts                     |  6 +-
 src/operator/concatMap.ts                     | 12 +++-
 src/operator/concatMapTo.ts                   | 16 +++---
 src/operator/exhaust.ts                       |  6 +-
 src/operator/exhaustMap.ts                    | 38 +++++++------
 src/operator/map.ts                           |  4 ++
 src/operator/mapTo.ts                         |  4 ++
 src/operator/merge.ts                         | 41 +++++++++++++-
 src/operator/mergeAll.ts                      |  6 +-
 src/operator/mergeMap.ts                      | 41 ++++++++------
 src/operator/mergeMapTo.ts                    | 49 ++++++++++-------
 src/operator/race.ts                          |  4 +-
 src/operator/switch.ts                        |  4 ++
 src/operator/switchMap.ts                     | 38 +++++++------
 src/operator/switchMapTo.ts                   | 40 +++++++-------
 src/operator/zipAll.ts                        |  5 ++
 26 files changed, 313 insertions(+), 173 deletions(-)

diff --git a/src/CoreOperators.ts b/src/CoreOperators.ts
index ccdec5ba0a..fcfce2f31b 100644
--- a/src/CoreOperators.ts
+++ b/src/CoreOperators.ts
@@ -1,6 +1,3 @@
-import {Observable} from './Observable';
-import {Scheduler} from './Scheduler';
-
 import {CombineLatestSignature} from './operator/combineLatest';
 import {WithLatestFromSignature} from './operator/withLatestFrom';
 import {ZipSignature} from './operator/zip';
@@ -70,6 +67,21 @@ import {TimeoutSignature} from './operator/timeout';
 import {TimeoutWithSignature} from './operator/timeoutWith';
 import {ToArraySignature} from './operator/toArray';
 import {ToPromiseSignature} from './operator/toPromise';
+import {CombineAllSignature} from './operator/combineAll';
+import {ConcatSignature} from './operator/concat';
+import {ConcatAllSignature} from './operator/concatAll';
+import {ConcatMapSignature} from './operator/concatMap';
+import {ConcatMapToSignature} from './operator/concatMapTo';
+import {MapSignature} from './operator/map';
+import {MapToSignature} from './operator/mapTo';
+import {MergeSignature} from './operator/merge';
+import {MergeAllSignature} from './operator/mergeAll';
+import {MergeMapSignature} from './operator/mergeMap';
+import {MergeMapToSignature} from './operator/mergeMapTo';
+import {SwitchSignature} from './operator/switch';
+import {SwitchMapSignature} from './operator/switchMap';
+import {SwitchMapToSignature} from './operator/switchMapTo';
+import {ZipAllSignature} from './operator/zipAll';
 
 export interface CoreOperators<T> {
   buffer: BufferSignature<T>;
@@ -79,12 +91,12 @@ export interface CoreOperators<T> {
   bufferWhen: BufferWhenSignature<T>;
   cache: CacheSignature<T>;
   catch: CatchSignature<T>;
-  combineAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
+  combineAll: CombineAllSignature<T>;
   combineLatest: CombineLatestSignature<T>;
-  concat?: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
-  concatAll?: () => Observable<T>;
-  concatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  concatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
+  concat: ConcatSignature<T>;
+  concatAll: ConcatAllSignature<T>;
+  concatMap: ConcatMapSignature<T>;
+  concatMapTo: ConcatMapToSignature<T>;
   count: CountSignature<T>;
   dematerialize: DematerializeSignature<T>;
   debounce: DebounceSignature<T>;
@@ -98,10 +110,8 @@ export interface CoreOperators<T> {
   filter: FilterSignature<T>;
   finally: FinallySignature<T>;
   first: FirstSignature<T>;
-  flatMap?: <R>(project: ((x: T, ix: number) => Observable<any>),
-                projectResult?: (x: T, y: any, ix: number, iy: number) => R,
-                concurrent?: number) => Observable<R>;
-  flatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
+  flatMap: MergeMapSignature<T>;
+  flatMapTo: MergeMapToSignature<T>;
   groupBy: GroupBySignature<T>;
   ignoreElements: IgnoreElementsSignature<T>;
   inspect: InspectSignature<T>;
@@ -110,14 +120,13 @@ export interface CoreOperators<T> {
   let: LetSignature<T>;
   letBind: LetSignature<T>;
   every: EverySignature<T>;
-  map?: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
-  mapTo?: <R>(value: R) => Observable<R>;
+  map: MapSignature<T>;
+  mapTo: MapToSignature<T>;
   materialize: MaterializeSignature<T>;
-  merge?: (...observables: any[]) => Observable<any>;
-  mergeAll?: (concurrent?: number) => Observable<T>;
-  mergeMap?: <R>(project: ((x: T, ix: number) => Observable<any>),
-                 projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  mergeMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
+  merge: MergeSignature<T>;
+  mergeAll: MergeAllSignature<T>;
+  mergeMap: MergeMapSignature<T>;
+  mergeMapTo: MergeMapToSignature<T>;
   multicast: MulticastSignature<T>;
   observeOn: ObserveOnSignature<T>;
   partition: PartitionSignature<T>;
@@ -141,9 +150,9 @@ export interface CoreOperators<T> {
   skipWhile: SkipWhileSignature<T>;
   startWith: StartWithSignature<T>;
   subscribeOn: SubscribeOnSignature<T>;
-  switch?: () => Observable<T>;
-  switchMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  switchMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
+  switch: SwitchSignature<T>;
+  switchMap: SwitchMapSignature<T>;
+  switchMapTo: SwitchMapToSignature<T>;
   take: TakeSignature<T>;
   takeLast: TakeLastSignature<T>;
   takeUntil: TakeUntilSignature<T>;
@@ -161,5 +170,5 @@ export interface CoreOperators<T> {
   windowWhen: WindowWhenSignature<T>;
   withLatestFrom: WithLatestFromSignature<T>;
   zip: ZipSignature<T>;
-  zipAll?: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
+  zipAll: ZipAllSignature<T>;
 }
diff --git a/src/Observable.ts b/src/Observable.ts
index bab0c89886..4c66fcc78e 100644
--- a/src/Observable.ts
+++ b/src/Observable.ts
@@ -1,6 +1,5 @@
 import {PartialObserver} from './Observer';
 import {Operator} from './Operator';
-import {Scheduler} from './Scheduler';
 import {Subscriber} from './Subscriber';
 import {Subscription} from './Subscription';
 import {root} from './util/root';
@@ -102,6 +101,21 @@ import {TimeoutSignature} from './operator/timeout';
 import {TimeoutWithSignature} from './operator/timeoutWith';
 import {ToArraySignature} from './operator/toArray';
 import {ToPromiseSignature} from './operator/toPromise';
+import {CombineAllSignature} from './operator/combineAll';
+import {ConcatSignature} from './operator/concat';
+import {ConcatAllSignature} from './operator/concatAll';
+import {ConcatMapSignature} from './operator/concatMap';
+import {ConcatMapToSignature} from './operator/concatMapTo';
+import {MapSignature} from './operator/map';
+import {MapToSignature} from './operator/mapTo';
+import {MergeSignature} from './operator/merge';
+import {MergeAllSignature} from './operator/mergeAll';
+import {MergeMapSignature} from './operator/mergeMap';
+import {MergeMapToSignature} from './operator/mergeMapTo';
+import {SwitchSignature} from './operator/switch';
+import {SwitchMapSignature} from './operator/switchMap';
+import {SwitchMapToSignature} from './operator/switchMapTo';
+import {ZipAllSignature} from './operator/zipAll';
 
 export type ObservableOrPromise<T> = Observable<T> | Promise<T>;
 export type ArrayOrIterator<T> = Iterator<T> | ArrayLike<T>;
@@ -264,12 +278,12 @@ export class Observable<T> implements CoreOperators<T>  {
   bufferWhen: BufferWhenSignature<T>;
   cache: CacheSignature<T>;
   catch: CatchSignature<T>;
-  combineAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
+  combineAll: CombineAllSignature<T>;
   combineLatest: CombineLatestSignature<T>;
-  concat: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
-  concatAll: () => Observable<any>;
-  concatMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  concatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
+  concat: ConcatSignature<T>;
+  concatAll: ConcatAllSignature<T>;
+  concatMap: ConcatMapSignature<T>;
+  concatMapTo: ConcatMapToSignature<T>;
   count: CountSignature<T>;
   dematerialize: DematerializeSignature<T>;
   debounce: DebounceSignature<T>;
@@ -283,10 +297,8 @@ export class Observable<T> implements CoreOperators<T>  {
   filter: FilterSignature<T>;
   finally: FinallySignature<T>;
   first: FirstSignature<T>;
-  flatMap: <R>(project: ((x: T, ix: number) => Observable<any>),
-               projectResult?: (x: T, y: any, ix: number, iy: number) => R,
-               concurrent?: number) => Observable<R>;
-  flatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
+  flatMap: MergeMapSignature<T>;
+  flatMapTo: MergeMapToSignature<T>;
   groupBy: GroupBySignature<T>;
   ignoreElements: IgnoreElementsSignature<T>;
   inspect: InspectSignature<T>;
@@ -295,15 +307,13 @@ export class Observable<T> implements CoreOperators<T>  {
   let: LetSignature<T>;
   letBind: LetSignature<T>;
   every: EverySignature<T>;
-  map: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
-  mapTo: <R>(value: R) => Observable<R>;
+  map: MapSignature<T>;
+  mapTo: MapToSignature<T>;
   materialize: MaterializeSignature<T>;
-  merge: (...observables: any[]) => Observable<any>;
-  mergeAll: (concurrent?: any) => Observable<any>;
-  mergeMap: <R>(project: ((x: T, ix: number) => Observable<any>),
-                projectResult?: (x: T, y: any, ix: number, iy: number) => R,
-                concurrent?: number) => Observable<R>;
-  mergeMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
+  merge: MergeSignature<T>;
+  mergeAll: MergeAllSignature<T>;
+  mergeMap: MergeMapSignature<T>;
+  mergeMapTo: MergeMapToSignature<T>;
   multicast: MulticastSignature<T>;
   observeOn: ObserveOnSignature<T>;
   partition: PartitionSignature<T>;
@@ -327,9 +337,9 @@ export class Observable<T> implements CoreOperators<T>  {
   skipWhile: SkipWhileSignature<T>;
   startWith: StartWithSignature<T>;
   subscribeOn: SubscribeOnSignature<T>;
-  switch: <R>() => Observable<R>;
-  switchMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  switchMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
+  switch: SwitchSignature<T>;
+  switchMap: SwitchMapSignature<T>;
+  switchMapTo: SwitchMapToSignature<T>;
   take: TakeSignature<T>;
   takeLast: TakeLastSignature<T>;
   takeUntil: TakeUntilSignature<T>;
@@ -347,7 +357,7 @@ export class Observable<T> implements CoreOperators<T>  {
   windowWhen: WindowWhenSignature<T>;
   withLatestFrom: WithLatestFromSignature<T>;
   zip: ZipSignature<T>;
-  zipAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
+  zipAll: ZipAllSignature<T>;
 
   /**
    * @method Symbol.observable
diff --git a/src/Rx.KitchenSink.ts b/src/Rx.KitchenSink.ts
index 87b968de23..5ed2620521 100644
--- a/src/Rx.KitchenSink.ts
+++ b/src/Rx.KitchenSink.ts
@@ -15,6 +15,8 @@ import {MinSignature} from './operator/min';
 import {PairwiseSignature} from './operator/pairwise';
 import {TimeIntervalSignature} from './operator/timeInterval';
 import {MergeScanSignature} from './operator/mergeScan';
+import {SwitchFirstSignature} from './operator/exhaust';
+import {SwitchFirstMapSignature} from './operator/exhaustMap';
 
 export interface KitchenSinkOperators<T> extends CoreOperators<T> {
   isEmpty?: IsEmptySignature<T>;
@@ -29,9 +31,8 @@ export interface KitchenSinkOperators<T> extends CoreOperators<T> {
   pairwise?: PairwiseSignature<T>;
   timeInterval?: TimeIntervalSignature<T>;
   mergeScan?: MergeScanSignature<T>;
-  exhaust?: () => Observable<T>;
-  exhaustMap?: <R>(project: ((x: T, ix: number) => Observable<any>),
-                       projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
+  exhaust?: SwitchFirstSignature<T>;
+  exhaustMap?: SwitchFirstMapSignature<T>;
 }
 
 // statics
diff --git a/src/add/operator/mergeMap.ts b/src/add/operator/mergeMap.ts
index a7e9142ecd..0c31b7b446 100644
--- a/src/add/operator/mergeMap.ts
+++ b/src/add/operator/mergeMap.ts
@@ -2,7 +2,7 @@
 import {Observable} from '../../Observable';
 import {mergeMap} from '../../operator/mergeMap';
 
-Observable.prototype.mergeMap = mergeMap;
-Observable.prototype.flatMap = mergeMap;
+Observable.prototype.mergeMap = <any>mergeMap;
+Observable.prototype.flatMap = <any>mergeMap;
 
 export var _void: void;
\ No newline at end of file
diff --git a/src/add/operator/mergeMapTo.ts b/src/add/operator/mergeMapTo.ts
index 66afeabf44..e578e6124e 100644
--- a/src/add/operator/mergeMapTo.ts
+++ b/src/add/operator/mergeMapTo.ts
@@ -2,6 +2,6 @@
 import {Observable} from '../../Observable';
 import {mergeMapTo} from '../../operator/mergeMapTo';
 
-Observable.prototype.mergeMapTo = mergeMapTo;
+Observable.prototype.mergeMapTo = <any>mergeMapTo;
 
 export var _void: void;
\ No newline at end of file
diff --git a/src/observable/BoundNodeCallbackObservable.ts b/src/observable/BoundNodeCallbackObservable.ts
index 6512d72e9c..847058b6e3 100644
--- a/src/observable/BoundNodeCallbackObservable.ts
+++ b/src/observable/BoundNodeCallbackObservable.ts
@@ -24,7 +24,7 @@ export class BoundNodeCallbackObservable<T> extends Observable<T> {
                    selector: Function | void = undefined,
                    scheduler?: Scheduler): Function {
     return (...args: any[]): Observable<T> => {
-      return new BoundNodeCallbackObservable(callbackFunc, <any>selector, args, scheduler);
+      return new BoundNodeCallbackObservable<T>(callbackFunc, <any>selector, args, scheduler);
     };
   }
 
diff --git a/src/observable/FromObservable.ts b/src/observable/FromObservable.ts
index 29b6f56d9e..f7e595a77e 100644
--- a/src/observable/FromObservable.ts
+++ b/src/observable/FromObservable.ts
@@ -35,11 +35,11 @@ export class FromObservable<T> extends Observable<T> {
         if (ish instanceof Observable && !scheduler) {
           return ish;
         }
-        return new FromObservable(ish, scheduler);
+        return new FromObservable<T>(ish, scheduler);
       } else if (isArray(ish)) {
-        return new ArrayObservable(ish, scheduler);
+        return new ArrayObservable<T>(ish, scheduler);
       } else if (isPromise(ish)) {
-        return new PromiseObservable(ish, scheduler);
+        return new PromiseObservable<T>(ish, scheduler);
       } else if (typeof ish[SymbolShim.iterator] === 'function' || typeof ish === 'string') {
         return new IteratorObservable<T>(<any>ish, null, null, scheduler);
       } else if (isArrayLike(ish)) {
diff --git a/src/observable/dom/WebSocketSubject.ts b/src/observable/dom/WebSocketSubject.ts
index 5806b86fc0..3fdba0656e 100644
--- a/src/observable/dom/WebSocketSubject.ts
+++ b/src/observable/dom/WebSocketSubject.ts
@@ -34,7 +34,7 @@ export class WebSocketSubject<T> extends Subject<T> {
   }
 
   static create<T>(urlConfigOrSource: string | WebSocketSubjectConfig): WebSocketSubject<T> {
-    return new WebSocketSubject(urlConfigOrSource);
+    return new WebSocketSubject<T>(urlConfigOrSource);
   }
 
   constructor(urlConfigOrSource: string | WebSocketSubjectConfig | Observable<T>, destination?: Observer<T>) {
diff --git a/src/operator/combineAll.ts b/src/operator/combineAll.ts
index 3dd1adfae9..902349fa4d 100644
--- a/src/operator/combineAll.ts
+++ b/src/operator/combineAll.ts
@@ -13,6 +13,11 @@ import {Observable} from '../Observable';
  *   most recent values from each collected observable as arguments, in order.
  * @returns {Observable} an observable of projected results or arrays of recent values.
  */
-export function combineAll<T, R>(project?: (...values: Array<any>) => R): Observable<R> {
+export function combineAll<R>(project?: (...values: Array<any>) => R): Observable<R> {
   return this.lift(new CombineLatestOperator(project));
 }
+
+export interface CombineAllSignature<T> {
+  (): Observable<T[]>;
+  <R>(project?: (...values: Array<T>) => R): Observable<R>;
+}
diff --git a/src/operator/concat.ts b/src/operator/concat.ts
index e4594c9c56..1fdf8cab63 100644
--- a/src/operator/concat.ts
+++ b/src/operator/concat.ts
@@ -1,4 +1,4 @@
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Scheduler} from '../Scheduler';
 import {isScheduler} from '../util/isScheduler';
 import {ArrayObservable} from '../observable/ArrayObservable';
@@ -12,10 +12,23 @@ import {MergeAllOperator} from './mergeAll';
  * @params {Scheduler} [scheduler] an optional scheduler to schedule each observable subscription on.
  * @returns {Observable} All values of each passed observable merged into a single observable, in order, in serial fashion.
  */
-export function concat<T, R>(...observables: Array<Observable<any> | Scheduler>): Observable<R> {
-  return concatStatic(this, ...observables);
+export function concat<T, R>(...observables: Array<ObservableInput<any> | Scheduler>): Observable<R> {
+  return concatStatic<T, R>(this, ...observables);
 }
 
+/* tslint:disable:max-line-length */
+export interface ConcatSignature<T> {
+  (scheduler?: Scheduler): Observable<T>;
+  <T2>(v2: ObservableInput<T2>, scheduler?: Scheduler): Observable<T | T2>;
+  <T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: Scheduler): Observable<T | T2 | T3>;
+  <T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+  <T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+  <T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+  (...observables: Array<ObservableInput<T> | Scheduler>): Observable<T>;
+  <R>(...observables: Array<ObservableInput<any> | Scheduler>): Observable<R>;
+}
+/* tslint:enable:max-line-length */
+
 /**
  * Joins multiple observables together by subscribing to them one at a time and merging their results
  * into the returned observable. Will wait for each observable to complete before moving on to the next.
@@ -23,12 +36,22 @@ export function concat<T, R>(...observables: Array<Observable<any> | Scheduler>)
  * @params {Scheduler} [scheduler] an optional scheduler to schedule each observable subscription on.
  * @returns {Observable} All values of each passed observable merged into a single observable, in order, in serial fashion.
  */
-export function concatStatic<T, R>(...observables: Array<Observable<any> | Scheduler>): Observable<R> {
+/* tslint:disable:max-line-length */
+export function concatStatic<T>(v1: ObservableInput<T>, scheduler?: Scheduler): Observable<T>;
+export function concatStatic<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, scheduler?: Scheduler): Observable<T | T2>;
+export function concatStatic<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: Scheduler): Observable<T | T2 | T3>;
+export function concatStatic<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+export function concatStatic<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+export function concatStatic<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+export function concatStatic<T>(...observables: (ObservableInput<T> | Scheduler)[]): Observable<T>;
+export function concatStatic<T, R>(...observables: (ObservableInput<any> | Scheduler)[]): Observable<R>;
+/* tslint:enable:max-line-length */
+export function concatStatic<T, R>(...observables: Array<ObservableInput<any> | Scheduler>): Observable<R> {
   let scheduler: Scheduler = null;
   let args = <any[]>observables;
   if (isScheduler(args[observables.length - 1])) {
     scheduler = args.pop();
   }
 
-  return new ArrayObservable(observables, scheduler).lift(new MergeAllOperator<T | R>(1));
+  return new ArrayObservable(observables, scheduler).lift(new MergeAllOperator<R>(1));
 }
diff --git a/src/operator/concatAll.ts b/src/operator/concatAll.ts
index 1f5eb64cbb..b0edd13c94 100644
--- a/src/operator/concatAll.ts
+++ b/src/operator/concatAll.ts
@@ -12,5 +12,9 @@ import {MergeAllOperator} from './mergeAll';
  * @returns {Observable} an observable of values merged from the incoming observables.
  */
 export function concatAll<T>(): T {
-  return this.lift(new MergeAllOperator(1));
+  return this.lift(new MergeAllOperator<T>(1));
+}
+
+export interface ConcatAllSignature<T> {
+  (): T;
 }
diff --git a/src/operator/concatMap.ts b/src/operator/concatMap.ts
index 2dfcf02adf..76ac80870d 100644
--- a/src/operator/concatMap.ts
+++ b/src/operator/concatMap.ts
@@ -1,5 +1,5 @@
 import {MergeMapOperator} from './mergeMap';
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 
 /**
  * Maps values from the source observable into new Observables, then merges them in a serialized fashion,
@@ -20,7 +20,13 @@ import {Observable} from '../Observable';
  * @returns {Observable} an observable of values merged from the projected Observables as they were subscribed to,
  * one at a time. Optionally, these values may have been projected from a passed `projectResult` argument.
  */
-export function concatMap<T, R, R2>(project: (value: T, index: number) => Observable<R>,
-                                    resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+export function concatMap<T, I, R>(project: (value: T, index: number) =>  ObservableInput<I>,
+                                   resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
   return this.lift(new MergeMapOperator(project, resultSelector, 1));
 }
+
+export interface ConcatMapSignature<T> {
+  <R>(project: (value: T, index: number) =>  ObservableInput<R>): Observable<R>;
+  <I, R>(project: (value: T, index: number) =>  ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+}
diff --git a/src/operator/concatMapTo.ts b/src/operator/concatMapTo.ts
index c702064dea..bd6a3c5249 100644
--- a/src/operator/concatMapTo.ts
+++ b/src/operator/concatMapTo.ts
@@ -1,4 +1,4 @@
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {MergeMapToOperator} from './mergeMapTo';
 
 /**
@@ -14,11 +14,13 @@ import {MergeMapToOperator} from './mergeMapTo';
  * @returns {Observable} an observable of values merged together by joining the passed observable
  * with itself, one after the other, for each value emitted from the source.
  */
-export function concatMapTo<T, R, R2>(observable: Observable<R>,
-                                      resultSelector?: (
-                                                outerValue: T,
-                                                innerValue: R,
-                                                outerIndex: number,
-                                                innerIndex: number) => R2): Observable<R2> {
+export function concatMapTo<T, I, R>(observable: Observable<I>,
+                                     resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R> {
   return this.lift(new MergeMapToOperator(observable, resultSelector, 1));
 }
+
+export interface ConcatMapToSignature<T> {
+  <R>(observable: ObservableInput<R>): Observable<R>;
+  <I, R>(observable: ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+}
diff --git a/src/operator/exhaust.ts b/src/operator/exhaust.ts
index 070a135dec..a534bbb89b 100644
--- a/src/operator/exhaust.ts
+++ b/src/operator/exhaust.ts
@@ -13,7 +13,11 @@ import {subscribeToResult} from '../util/subscribeToResult';
  * @returns {Observable} an Observable which contains all of the items of the first Observable and following Observables in the source.
  */
 export function exhaust<T>(): Observable<T> {
-  return this.lift(new SwitchFirstOperator());
+  return this.lift(new SwitchFirstOperator<T>());
+}
+
+export interface SwitchFirstSignature<T> {
+  (): T;
 }
 
 class SwitchFirstOperator<T> implements Operator<T, T> {
diff --git a/src/operator/exhaustMap.ts b/src/operator/exhaustMap.ts
index b6dbc09ebd..94677d4728 100644
--- a/src/operator/exhaustMap.ts
+++ b/src/operator/exhaustMap.ts
@@ -1,5 +1,5 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {OuterSubscriber} from '../OuterSubscriber';
 import {InnerSubscriber} from '../InnerSubscriber';
@@ -12,33 +12,35 @@ import {subscribeToResult} from '../util/subscribeToResult';
  * @param {function} [resultSelector] optional function for then selecting on each inner Observable.
  * @returns {Observable} an Observable containing all the projected Observables of each item of the source concatenated together.
  */
-export function exhaustMap<T, R, R2>(project: (value: T, index: number) => Observable<R>,
-                                     resultSelector?: (
-                                            outerValue: T,
-                                            innerValue: R,
-                                            outerIndex: number,
-                                            innerIndex: number) => R2): Observable<R2> {
+export function exhaustMap<T, I, R>(project: (value: T, index: number) => ObservableInput<I>,
+                                    resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R> {
   return this.lift(new SwitchFirstMapOperator(project, resultSelector));
 }
 
-class SwitchFirstMapOperator<T, R, R2> implements Operator<T, R2> {
-  constructor(private project: (value: T, index: number) => Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+export interface SwitchFirstMapSignature<T> {
+  <R>(project: (value: T, index: number) => ObservableInput<R>): Observable<R>;
+  <I, R>(project: (value: T, index: number) => ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+}
+
+class SwitchFirstMapOperator<T, I, R> implements Operator<T, R> {
+  constructor(private project: (value: T, index: number) => ObservableInput<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
   }
 
-  call(subscriber: Subscriber<R2>): Subscriber<T> {
+  call(subscriber: Subscriber<R>): Subscriber<T> {
     return new SwitchFirstMapSubscriber(subscriber, this.project, this.resultSelector);
   }
 }
 
-class SwitchFirstMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
+class SwitchFirstMapSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   private hasSubscription: boolean = false;
   private hasCompleted: boolean = false;
   private index: number = 0;
 
-  constructor(destination: Subscriber<R2>,
-              private project: (value: T, index: number) => Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+  constructor(destination: Subscriber<R>,
+              private project: (value: T, index: number) => ObservableInput<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
     super(destination);
   }
 
@@ -67,9 +69,9 @@ class SwitchFirstMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, I>): void {
     const { resultSelector, destination } = this;
     if (resultSelector) {
       this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex);
@@ -78,7 +80,7 @@ class SwitchFirstMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  private trySelectResult(outerValue: T, innerValue: R,
+  private trySelectResult(outerValue: T, innerValue: I,
                           outerIndex: number, innerIndex: number): void {
     const { resultSelector, destination } = this;
     try {
diff --git a/src/operator/map.ts b/src/operator/map.ts
index 929fd5fd3a..113c57e8d8 100644
--- a/src/operator/map.ts
+++ b/src/operator/map.ts
@@ -19,6 +19,10 @@ export function map<T, R>(project: (value: T, index: number) => R, thisArg?: any
   return this.lift(new MapOperator(project, thisArg));
 }
 
+export interface MapSignature<T> {
+  <R>(project: (value: T, index: number) => R, thisArg?: any): Observable<R>;
+}
+
 class MapOperator<T, R> implements Operator<T, R> {
   constructor(private project: (value: T, index: number) => R, private thisArg: any) {
   }
diff --git a/src/operator/mapTo.ts b/src/operator/mapTo.ts
index 56674d156b..41e01a0aeb 100644
--- a/src/operator/mapTo.ts
+++ b/src/operator/mapTo.ts
@@ -14,6 +14,10 @@ export function mapTo<T, R>(value: R): Observable<R> {
   return this.lift(new MapToOperator(value));
 }
 
+export interface MapToSignature<T> {
+  <R>(value: R): Observable<R>;
+}
+
 class MapToOperator<T, R> implements Operator<T, R> {
 
   value: R;
diff --git a/src/operator/merge.ts b/src/operator/merge.ts
index 2c6984fcb7..f47fdf8ec7 100644
--- a/src/operator/merge.ts
+++ b/src/operator/merge.ts
@@ -1,4 +1,4 @@
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Scheduler} from '../Scheduler';
 import {ArrayObservable} from '../observable/ArrayObservable';
 import {MergeAllOperator} from './mergeAll';
@@ -12,12 +12,47 @@ import {isScheduler} from '../util/isScheduler';
  * @param {Observable} input Observables
  * @returns {Observable} an Observable that emits items that are the result of every input Observable.
  */
-export function merge<T, R>(...observables: Array<Observable<any> | Scheduler | number>): Observable<R> {
+export function merge<T, R>(...observables: Array<ObservableInput<any> | Scheduler | number>): Observable<R> {
   observables.unshift(this);
   return mergeStatic.apply(this, observables);
 }
 
-export function mergeStatic<T, R>(...observables: Array<Observable<any> | Scheduler | number>): Observable<R> {
+/* tslint:disable:max-line-length */
+export interface MergeSignature<T> {
+  (scheduler?: Scheduler): Observable<T>;
+  (concurrent?: number, scheduler?: Scheduler): Observable<T>;
+  <T2>(v2: ObservableInput<T2>, scheduler?: Scheduler): Observable<T | T2>;
+  <T2>(v2: ObservableInput<T2>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2>;
+  <T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: Scheduler): Observable<T | T2 | T3>;
+  <T2, T3>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3>;
+  <T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+  <T2, T3, T4>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+  <T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+  <T2, T3, T4, T5>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+  <T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+  <T2, T3, T4, T5, T6>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+  (...observables: Array<ObservableInput<T> | Scheduler | number>): Observable<T>;
+  <R>(...observables: Array<ObservableInput<any> | Scheduler | number>): Observable<R>;
+}
+/* tslint:enable:max-line-length */
+
+/* tslint:disable:max-line-length */
+export function mergeStatic<T>(v1: ObservableInput<T>, scheduler?: Scheduler): Observable<T>;
+export function mergeStatic<T>(v1: ObservableInput<T>, concurrent?: number, scheduler?: Scheduler): Observable<T>;
+export function mergeStatic<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, scheduler?: Scheduler): Observable<T | T2>;
+export function mergeStatic<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2>;
+export function mergeStatic<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler?: Scheduler): Observable<T | T2 | T3>;
+export function mergeStatic<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3>;
+export function mergeStatic<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+export function mergeStatic<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3 | T4>;
+export function mergeStatic<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+export function mergeStatic<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5>;
+export function mergeStatic<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+export function mergeStatic<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, concurrent?: number, scheduler?: Scheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
+export function mergeStatic<T>(...observables: (ObservableInput<T> | Scheduler | number)[]): Observable<T>;
+export function mergeStatic<T, R>(...observables: (ObservableInput<any> | Scheduler | number)[]): Observable<R>;
+/* tslint:enable:max-line-length */
+export function mergeStatic<T, R>(...observables: Array<ObservableInput<any> | Scheduler | number>): Observable<R> {
  let concurrent = Number.POSITIVE_INFINITY;
  let scheduler: Scheduler = null;
   let last: any = observables[observables.length - 1];
diff --git a/src/operator/mergeAll.ts b/src/operator/mergeAll.ts
index 314f206e8e..f2b79ed82b 100644
--- a/src/operator/mergeAll.ts
+++ b/src/operator/mergeAll.ts
@@ -6,7 +6,11 @@ import {OuterSubscriber} from '../OuterSubscriber';
 import {subscribeToResult} from '../util/subscribeToResult';
 
 export function mergeAll<T>(concurrent: number = Number.POSITIVE_INFINITY): T {
-  return this.lift(new MergeAllOperator(concurrent));
+  return this.lift(new MergeAllOperator<T>(concurrent));
+}
+
+export interface MergeAllSignature<T> {
+  (): T;
 }
 
 export class MergeAllOperator<T> implements Operator<Observable<T>, T> {
diff --git a/src/operator/mergeMap.ts b/src/operator/mergeMap.ts
index 586be05980..c4f22c9dd3 100644
--- a/src/operator/mergeMap.ts
+++ b/src/operator/mergeMap.ts
@@ -1,4 +1,4 @@
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Operator} from '../Operator';
 import {Subscriber} from '../Subscriber';
 import {Subscription} from '../Subscription';
@@ -17,34 +17,41 @@ import {InnerSubscriber} from '../InnerSubscriber';
  * @returns {Observable} an Observable that emits the result of applying the transformation function to each item
  * emitted by the source Observable and merging the results of the Observables obtained from this transformation
  */
-export function mergeMap<T, R, R2>(project: (value: T, index: number) => Observable<R>,
-                                   resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2 | number,
-                                   concurrent: number = Number.POSITIVE_INFINITY): Observable<R2> {
+export function mergeMap<T, I, R>(project: (value: T, index: number) => ObservableInput<I>,
+                                  resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R | number,
+                                  concurrent: number = Number.POSITIVE_INFINITY): Observable<R> {
   return this.lift(new MergeMapOperator(project, <any>resultSelector, concurrent));
 }
 
-export class MergeMapOperator<T, R, R2> implements Operator<T, R> {
-  constructor(private project: (value: T, index: number) => Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2,
+export interface MergeMapSignature<T> {
+  <R>(project: (value: T, index: number) => ObservableInput<R>, concurrent?: number): Observable<R>;
+  <I, R>(project: (value: T, index: number) => ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
+         concurrent?: number): Observable<R>;
+}
+
+export class MergeMapOperator<T, I, R> implements Operator<T, I> {
+  constructor(private project: (value: T, index: number) => ObservableInput<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
               private concurrent: number = Number.POSITIVE_INFINITY) {
   }
 
-  call(observer: Subscriber<R>): Subscriber<T> {
+  call(observer: Subscriber<I>): Subscriber<T> {
     return new MergeMapSubscriber(
       observer, this.project, this.resultSelector, this.concurrent
     );
   }
 }
 
-export class MergeMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
+export class MergeMapSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   private hasCompleted: boolean = false;
   private buffer: Observable<any>[] = [];
   private active: number = 0;
   protected index: number = 0;
 
-  constructor(destination: Subscriber<R>,
-              private project: (value: T, index: number) => Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2,
+  constructor(destination: Subscriber<I>,
+              private project: (value: T, index: number) => ObservableInput<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
               private concurrent: number = Number.POSITIVE_INFINITY) {
     super(destination);
   }
@@ -71,7 +78,7 @@ export class MergeMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
   }
 
   private _innerSub(ish: any, value: T, index: number): void {
-    this.add(subscribeToResult<T, R>(this, ish, value, index));
+    this.add(subscribeToResult<T, I>(this, ish, value, index));
   }
 
   protected _complete(): void {
@@ -81,9 +88,9 @@ export class MergeMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, I>): void {
     if (this.resultSelector) {
       this._notifyResultSelector(outerValue, innerValue, outerIndex, innerIndex);
     } else {
@@ -91,8 +98,8 @@ export class MergeMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  _notifyResultSelector(outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) {
-    let result: any;
+  _notifyResultSelector(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) {
+    let result: R;
     try {
       result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);
     } catch (err) {
diff --git a/src/operator/mergeMapTo.ts b/src/operator/mergeMapTo.ts
index 0d08f352b3..7136d6a567 100644
--- a/src/operator/mergeMapTo.ts
+++ b/src/operator/mergeMapTo.ts
@@ -1,4 +1,4 @@
-import {Observable} from '../Observable';
+import {Observable, ObservableInput, ObservableOrPromise} from '../Observable';
 import {Operator} from '../Operator';
 import {PartialObserver} from '../Observer';
 import {Subscriber} from '../Subscriber';
@@ -7,34 +7,41 @@ import {OuterSubscriber} from '../OuterSubscriber';
 import {InnerSubscriber} from '../InnerSubscriber';
 import {subscribeToResult} from '../util/subscribeToResult';
 
-export function mergeMapTo<T, R, R2>(observable: Observable<R>,
-                                     resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2 | number,
-                                     concurrent: number = Number.POSITIVE_INFINITY): Observable<R2> {
+export function mergeMapTo<T, I, R>(observable: Observable<I>,
+                                    resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R | number,
+                                    concurrent: number = Number.POSITIVE_INFINITY): Observable<R> {
   return this.lift(new MergeMapToOperator(observable, <any>resultSelector, concurrent));
 }
 
-// TODO: Figure out correct signature here: an Operator<Observable<T>, R2>
-//       needs to implement call(observer: Subscriber<R2>): Subscriber<Observable<T>>
-export class MergeMapToOperator<T, R, R2> implements Operator<Observable<T>, R2> {
-  constructor(private ish: Observable<R> | Promise<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2,
+export interface MergeMapToSignature<T> {
+  <R>(observable: ObservableInput<R>, concurrent?: number): Observable<R>;
+  <I, R>(observable: ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
+         concurrent?: number): Observable<R>;
+}
+
+// TODO: Figure out correct signature here: an Operator<Observable<T>, R>
+//       needs to implement call(observer: Subscriber<R>): Subscriber<Observable<T>>
+export class MergeMapToOperator<T, I, R> implements Operator<Observable<T>, R> {
+  constructor(private ish: ObservableOrPromise<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
               private concurrent: number = Number.POSITIVE_INFINITY) {
   }
 
-  call(observer: Subscriber<R2>): Subscriber<any> {
+  call(observer: Subscriber<R>): Subscriber<any> {
     return new MergeMapToSubscriber(observer, this.ish, this.resultSelector, this.concurrent);
   }
 }
 
-export class MergeMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
+export class MergeMapToSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   private hasCompleted: boolean = false;
   private buffer: Observable<any>[] = [];
   private active: number = 0;
   protected index: number = 0;
 
-  constructor(destination: Subscriber<R2>,
-              private ish: Observable<R> | Promise<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2,
+  constructor(destination: Subscriber<R>,
+              private ish: ObservableOrPromise<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
               private concurrent: number = Number.POSITIVE_INFINITY) {
     super(destination);
   }
@@ -54,11 +61,11 @@ export class MergeMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
   }
 
   private _innerSub(ish: any,
-                    destination: PartialObserver<R>,
-                    resultSelector: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2,
+                    destination: PartialObserver<I>,
+                    resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R,
                     value: T,
                     index: number): void {
-    this.add(subscribeToResult<T, R>(this, ish, value, index));
+    this.add(subscribeToResult<T, I>(this, ish, value, index));
   }
 
   protected _complete(): void {
@@ -68,9 +75,9 @@ export class MergeMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, I>): void {
     const { resultSelector, destination } = this;
     if (resultSelector) {
       this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex);
@@ -79,10 +86,10 @@ export class MergeMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  private trySelectResult(outerValue: T, innerValue: R,
+  private trySelectResult(outerValue: T, innerValue: I,
                           outerIndex: number, innerIndex: number): void {
     const { resultSelector, destination } = this;
-    let result: R2;
+    let result: R;
     try {
       result = resultSelector(outerValue, innerValue, outerIndex, innerIndex);
     } catch (err) {
diff --git a/src/operator/race.ts b/src/operator/race.ts
index 92175c0b46..c2d555a335 100644
--- a/src/operator/race.ts
+++ b/src/operator/race.ts
@@ -36,7 +36,7 @@ export interface RaceSignature<T> {
  * @returns {Observable} an Observable that mirrors the output of the first Observable to emit an item.
  */
 export function raceStatic<T>(...observables: Array<Observable<T> | Array<Observable<T>>>): Observable<T>;
-export function raceStatic<R>(...observables: Array<Observable<any> | Array<Observable<any>>>): Observable<R> {
+export function raceStatic<T>(...observables: Array<Observable<any> | Array<Observable<any>>>): Observable<T> {
   // if the only argument is an array, it was most likely called with
   // `pair([obs1, obs2, ...])`
   if (observables.length === 1) {
@@ -47,7 +47,7 @@ export function raceStatic<R>(...observables: Array<Observable<any> | Array<Obse
     }
   }
 
-  return new ArrayObservable(observables).lift(new RaceOperator());
+  return new ArrayObservable<T>(<any>observables).lift(new RaceOperator<T>());
 }
 
 export class RaceOperator<T> implements Operator<T, T> {
diff --git a/src/operator/switch.ts b/src/operator/switch.ts
index 184dfadbed..f6d2161aef 100644
--- a/src/operator/switch.ts
+++ b/src/operator/switch.ts
@@ -24,6 +24,10 @@ export function _switch<T>(): T {
   return this.lift(new SwitchOperator());
 }
 
+export interface SwitchSignature<T> {
+  (): T;
+}
+
 class SwitchOperator<T, R> implements Operator<T, R> {
   call(subscriber: Subscriber<R>): Subscriber<T> {
     return new SwitchSubscriber(subscriber);
diff --git a/src/operator/switchMap.ts b/src/operator/switchMap.ts
index 4b85ab0532..6ca2e78096 100644
--- a/src/operator/switchMap.ts
+++ b/src/operator/switchMap.ts
@@ -1,5 +1,5 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {Subscription} from '../Subscription';
 import {OuterSubscriber} from '../OuterSubscriber';
@@ -16,32 +16,34 @@ import {subscribeToResult} from '../util/subscribeToResult';
  * @returns {Observable} an Observable that emits the items emitted by the Observable returned from applying func to
  * the most recently emitted item emitted by the source Observable.
  */
-export function switchMap<T, R, R2>(project: (value: T, index: number) => Observable<R>,
-                                    resultSelector?: (
-                                             outerValue: T,
-                                             innerValue: R,
-                                             outerIndex: number,
-                                             innerIndex: number) => R2): Observable<R2> {
+export function switchMap<T, I, R>(project: (value: T, index: number) => ObservableInput<I>,
+                                   resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R> {
   return this.lift(new SwitchMapOperator(project, resultSelector));
 }
 
-class SwitchMapOperator<T, R, R2> implements Operator<T, R> {
-  constructor(private project: (value: T, index: number) => Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+export interface SwitchMapSignature<T> {
+  <R>(project: (value: T, index: number) => ObservableInput<R>): Observable<R>;
+  <I, R>(project: (value: T, index: number) => ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+}
+
+class SwitchMapOperator<T, I, R> implements Operator<T, I> {
+  constructor(private project: (value: T, index: number) => ObservableInput<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
   }
 
-  call(subscriber: Subscriber<R>): Subscriber<T> {
+  call(subscriber: Subscriber<I>): Subscriber<T> {
     return new SwitchMapSubscriber(subscriber, this.project, this.resultSelector);
   }
 }
 
-class SwitchMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
+class SwitchMapSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   private index: number = 0;
   private innerSubscription: Subscription;
 
-  constructor(destination: Subscriber<R>,
-              private project: (value: T, index: number) => Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+  constructor(destination: Subscriber<I>,
+              private project: (value: T, index: number) => ObservableInput<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
     super(destination);
   }
 
@@ -84,9 +86,9 @@ class SwitchMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, I>): void {
     if (this.resultSelector) {
       this._tryNotifyNext(outerValue, innerValue, outerIndex, innerIndex);
     } else {
@@ -94,7 +96,7 @@ class SwitchMapSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  _tryNotifyNext(outerValue: T, innerValue: R, outerIndex: number, innerIndex: number): void {
+  _tryNotifyNext(outerValue: T, innerValue: I, outerIndex: number, innerIndex: number): void {
     let result: any;
     try {
       result = this.resultSelector(outerValue, innerValue, outerIndex, innerIndex);
diff --git a/src/operator/switchMapTo.ts b/src/operator/switchMapTo.ts
index ea712ff0f8..9b152d0cd8 100644
--- a/src/operator/switchMapTo.ts
+++ b/src/operator/switchMapTo.ts
@@ -1,37 +1,39 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {Subscription} from '../Subscription';
 import {OuterSubscriber} from '../OuterSubscriber';
 import {InnerSubscriber} from '../InnerSubscriber';
 import {subscribeToResult} from '../util/subscribeToResult';
 
-export function switchMapTo<T, R, R2>(observable: Observable<R>,
-                                      resultSelector?: (
-                                                 outerValue: T,
-                                                 innerValue: R,
-                                                 outerIndex: number,
-                                                 innerIndex: number) => R2): Observable<R2> {
+export function switchMapTo<T, I, R>(observable: Observable<I>,
+                                     resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R> {
   return this.lift(new SwitchMapToOperator(observable, resultSelector));
 }
 
-class SwitchMapToOperator<T, R, R2> implements Operator<T, R> {
-  constructor(private observable: Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+export interface SwitchMapToSignature<T> {
+  <R>(observable: ObservableInput<R>): Observable<R>;
+  <I, R>(observable: ObservableInput<I>,
+         resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
+}
+
+class SwitchMapToOperator<T, I, R> implements Operator<T, I> {
+  constructor(private observable: Observable<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
   }
 
-  call(subscriber: Subscriber<R>): Subscriber<T> {
+  call(subscriber: Subscriber<I>): Subscriber<T> {
     return new SwitchMapToSubscriber(subscriber, this.observable, this.resultSelector);
   }
 }
 
-class SwitchMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
+class SwitchMapToSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   private index: number = 0;
   private innerSubscription: Subscription;
 
-  constructor(destination: Subscriber<R>,
-              private inner: Observable<R>,
-              private resultSelector?: (outerValue: T, innerValue: R, outerIndex: number, innerIndex: number) => R2) {
+  constructor(destination: Subscriber<I>,
+              private inner: Observable<I>,
+              private resultSelector?: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R) {
     super(destination);
   }
 
@@ -62,9 +64,9 @@ class SwitchMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, I>): void {
     const { resultSelector, destination } = this;
     if (resultSelector) {
       this.tryResultSelector(outerValue, innerValue, outerIndex, innerIndex);
@@ -73,10 +75,10 @@ class SwitchMapToSubscriber<T, R, R2> extends OuterSubscriber<T, R> {
     }
   }
 
-  private tryResultSelector(outerValue: T, innerValue: R,
+  private tryResultSelector(outerValue: T, innerValue: I,
                             outerIndex: number, innerIndex: number): void {
     const { resultSelector, destination } = this;
-    let result: R2;
+    let result: R;
     try {
       result = resultSelector(outerValue, innerValue, outerIndex, innerIndex);
     } catch (err) {
diff --git a/src/operator/zipAll.ts b/src/operator/zipAll.ts
index 3f33b3d88f..aefe3afba0 100644
--- a/src/operator/zipAll.ts
+++ b/src/operator/zipAll.ts
@@ -4,3 +4,8 @@ import {Observable} from '../Observable';
 export function zipAll<T, R>(project?: (...values: Array<any>) => R): Observable<R> {
   return this.lift(new ZipOperator(project));
 }
+
+export interface ZipAllSignature<T> {
+  (): Observable<T[]>;
+  <R>(project?: (...values: Array<T>) => R): Observable<R>;
+}