style(typings): Updated typings to have a better flow through type inference

Author: david-driscoll

src/Observable.ts

@@ -246,7 +246,6 @@ export class Observable<T> implements CoreOperators<T>  {
   zipAll: operators.operator_proto_zipAll<T>;
 }
 
-export type ObservableOrPromise<T> = Observable<T> | PromiseLike<T>;
-export type ArrayOrIterable<T> = IterableShim<T> | ArrayLike<T> | Array<T>;
-export type ObservableOrIterable<T> = ObservableOrPromise<T> | ArrayOrIterable<T>;
-export type ObservableOrPromiseOrIterable<T> = Observable<T> | PromiseLike<T> | IterableShim<T>;
+export type ObservableOrPromise<T> = Observable<T> | Promise<T>;
+export type ArrayOrIterator<T> = Iterator<T> | ArrayLike<T> | Array<T>;
+export type ObservableOrPromiseOrIterator<T> = ObservableOrPromise<T> | Iterator<T>;

src/observables/FromObservable.ts

@@ -3,33 +3,37 @@ import {IteratorObservable} from'./IteratorObservable';
 import {ArrayObservable} from './ArrayObservable';
 
 import {Scheduler} from '../Scheduler';
+import {Observable, ObservableOrPromise, ArrayOrIterator} from '../Observable';
 import {$$observable} from '../util/Symbol_observable';
-import {$$iterator} from '../util/Symbol_iterator';
-import {Observable} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {ObserveOnSubscriber} from '../operators/observeOn-support';
 import {immediate} from '../schedulers/immediate';
+import {isPromise} from '../util/isPromise';
+import {isObservable} from '../util/isObservable';
+import {isIterator} from '../util/isIterator';
 
 const isArray = Array.isArray;
 
 export class FromObservable<T> extends Observable<T> {
-  constructor(private ish: any, private scheduler: Scheduler) {
+  constructor(private ish: Observable<T>, private scheduler: Scheduler) {
     super(null);
   }
 
+  static create<T>(ish: ObservableOrPromise<T>, scheduler?: Scheduler): Observable<T>;
+  static create<T>(ish: ArrayOrIterator<T>, scheduler?: Scheduler): Observable<T>;
   static create<T>(ish: any, scheduler: Scheduler = immediate): Observable<T> {
     if (ish) {
       if (isArray(ish)) {
         return new ArrayObservable<T>(ish, scheduler);
-      } else if (typeof ish.then === 'function') {
+      } else if (isPromise(ish)) {
         return new PromiseObservable<T>(ish, scheduler);
-      } else if (typeof ish[$$observable] === 'function') {
+      } else if (isObservable(ish)) {
         if (ish instanceof Observable) {
           return ish;
         }
         return new FromObservable<T>(ish, scheduler);
-      } else if (typeof ish[$$iterator] === 'function') {
-        return new IteratorObservable<T>(ish, null, null, scheduler);
+      } else if (isIterator(ish)) {
+        return new IteratorObservable<T, T>(ish, null, null, scheduler);
       }
     }