diff --git a/spec/observables/IteratorObservable-spec.ts b/spec/observables/IteratorObservable-spec.ts
index 67699cd3bc..3149f213a2 100644
--- a/spec/observables/IteratorObservable-spec.ts
+++ b/spec/observables/IteratorObservable-spec.ts
@@ -32,12 +32,6 @@ describe('IteratorObservable', () => {
     }).to.throw(Error, 'object is not iterable');
   });
 
-  it('should not accept non-function project', () => {
-    expect(() => {
-      IteratorObservable.create([], 42);
-    }).to.throw(Error, 'when provided, `project` must be a function.');
-  });
-
   it('should emit members of an array iterator', (done: MochaDone) => {
     const expected = [10, 20, 30, 40];
     IteratorObservable.create([10, 20, 30, 40])
@@ -55,8 +49,6 @@ describe('IteratorObservable', () => {
   it('should emit members of an array iterator on a particular scheduler', () => {
     const source = IteratorObservable.create(
       [10, 20, 30, 40],
-      (x: number) => x,
-      null,
       rxTestScheduler
     );
 
@@ -65,32 +57,12 @@ describe('IteratorObservable', () => {
     expectObservable(source).toBe('(abcd|)', values);
   });
 
-  it('should emit members of an array iterator on a particular scheduler, project throws', () => {
-    const source = IteratorObservable.create(
-      [10, 20, 30, 40],
-      (x: number) => {
-        if (x === 30) {
-          throw 'error';
-        }
-        return x * x;
-      },
-      null,
-      rxTestScheduler
-    );
-
-    const values = { a: 100, b: 400 };
-
-    expectObservable(source).toBe('(ab#)', values);
-  });
-
   it('should emit members of an array iterator on a particular scheduler, ' +
   'but is unsubscribed early', (done: MochaDone) => {
     const expected = [10, 20, 30, 40];
 
     const source = IteratorObservable.create(
       [10, 20, 30, 40],
-      (x: number) => x,
-      null,
       Rx.Scheduler.queue
     );
 
@@ -110,43 +82,6 @@ describe('IteratorObservable', () => {
     source.subscribe(subscriber);
   });
 
-  it('should emit members of an array iterator, and project them', (done: MochaDone) => {
-    const expected = [100, 400, 900, 1600];
-    IteratorObservable.create([10, 20, 30, 40], (x: number) => x * x)
-      .subscribe(
-        (x: number) => { expect(x).to.equal(expected.shift()); },
-        (x) => {
-          done(new Error('should not be called'));
-        }, () => {
-          expect(expected.length).to.equal(0);
-          done();
-        }
-      );
-  });
-
-  it('should emit members of an array iterator, and project but raise an error', (done: MochaDone) => {
-    const expected = [100, 400];
-    function project(x) {
-      if (x === 30) {
-        throw new Error('boom');
-      } else {
-        return x * x;
-      }
-    }
-    IteratorObservable.create([10, 20, 30, 40], project)
-      .subscribe(
-        (x: number) => {
-          expect(x).to.equal(expected.shift());
-        },
-        (err: any) => {
-          expect(expected.length).to.equal(0);
-          expect(err.message).to.equal('boom');
-          done();
-        }, () => {
-          done(new Error('should not be called'));
-        });
-  });
-
   it('should emit characters of a string iterator', (done: MochaDone) => {
     const expected = ['f', 'o', 'o'];
     IteratorObservable.create('foo')
@@ -161,20 +96,6 @@ describe('IteratorObservable', () => {
       );
   });
 
-  it('should emit characters of a string iterator, and project them', (done: MochaDone) => {
-    const expected = ['F', 'O', 'O'];
-    IteratorObservable.create('foo', (x: string) => x.toUpperCase())
-      .subscribe(
-        (x: string) => { expect(x).to.equal(expected.shift()); },
-        (x) => {
-          done(new Error('should not be called'));
-        }, () => {
-          expect(expected.length).to.equal(0);
-          done();
-        }
-      );
-  });
-
   it('should be possible to unsubscribe in the middle of the iteration', (done: MochaDone) => {
     const expected = [10, 20, 30];
 
diff --git a/spec/observables/from-spec.ts b/spec/observables/from-spec.ts
index 2f60af3092..1bef579ef0 100644
--- a/spec/observables/from-spec.ts
+++ b/spec/observables/from-spec.ts
@@ -34,10 +34,10 @@ describe('Observable.from', () => {
     });
   });
 
-  it('should return T and map for arrays', () => {
+  it('should return T for arrays', () => {
     type(() => {
       /* tslint:disable:no-unused-variable */
-      let o1: Rx.Observable<number> = Observable.from(<number[]>[], x => x.toString(), null, Rx.Scheduler.asap);
+      let o1: Rx.Observable<number> = Observable.from(<number[]>[], Rx.Scheduler.asap);
       /* tslint:enable:no-unused-variable */
     });
   });
@@ -100,83 +100,5 @@ describe('Observable.from', () => {
         );
       expect(nextInvoked).to.equal(false);
     });
-    it(`should accept ${source.name} and projection`, (done: MochaDone) => {
-      let nextInvoked = false;
-      Observable.from(source.value, x => x + 'x')
-        .subscribe(
-          (x: string) => {
-            nextInvoked = true;
-            expect(x).to.equal('xx');
-          },
-          (x) => {
-            done(new Error('should not be called'));
-          },
-          () => {
-            expect(nextInvoked).to.equal(true);
-            done();
-          }
-        );
-    });
-    it(`should accept ${source.name}, projection and scheduler`, (done: MochaDone) => {
-      let nextInvoked = false;
-      Observable.from(source.value, x => x + 'x', Rx.Scheduler.async)
-        .subscribe(
-          (x: string) => {
-            nextInvoked = true;
-            expect(x).to.equal('xx');
-          },
-          (x) => {
-            done(new Error('should not be called'));
-          },
-          () => {
-            expect(nextInvoked).to.equal(true);
-            done();
-          }
-        );
-      expect(nextInvoked).to.equal(false);
-    });
-    it(`should accept ${source.name}, projection and context`, (done: MochaDone) => {
-      const projection = function(x) {
-        expect(this.foo).to.equal('bar');
-        return x + 'x';
-      };
-      let nextInvoked = false;
-      Observable.from(source.value, projection, { foo: 'bar' })
-        .subscribe(
-          (x: string) => {
-            nextInvoked = true;
-            expect(x).to.equal('xx');
-          },
-          (x) => {
-            done(new Error('should not be called'));
-          },
-          () => {
-            expect(nextInvoked).to.equal(true);
-            done();
-          }
-        );
-    });
-    it(`should accept ${source.name}, projection, context and scheduler`, (done: MochaDone) => {
-      const projection = function(x) {
-        expect(this.foo).to.equal('bar');
-        return x + 'x';
-      };
-      let nextInvoked = false;
-      Observable.from(source.value, projection, { foo: 'bar' }, Rx.Scheduler.async)
-        .subscribe(
-          (x: string) => {
-            nextInvoked = true;
-            expect(x).to.equal('xx');
-          },
-          (x) => {
-            done(new Error('should not be called'));
-          },
-          () => {
-            expect(nextInvoked).to.equal(true);
-            done();
-          }
-        );
-      expect(nextInvoked).to.equal(false);
-    });
   }
 });
diff --git a/spec/support/default.opts b/spec/support/default.opts
index 04406230fa..5cedfe5bd5 100644
--- a/spec/support/default.opts
+++ b/spec/support/default.opts
@@ -5,7 +5,7 @@
 --ui spec-js/helpers/testScheduler-ui.js
 
 --reporter dot
---bail
+
 --full-trace
 --check-leaks
 --globals WebSocket,FormData,XDomainRequest,ActiveXObject
diff --git a/src/observable/ArrayLikeObservable.ts b/src/observable/ArrayLikeObservable.ts
index 3fd9dddc51..f92e54beff 100644
--- a/src/observable/ArrayLikeObservable.ts
+++ b/src/observable/ArrayLikeObservable.ts
@@ -12,21 +12,19 @@ import {TeardownLogic} from '../Subscription';
  */
 export class ArrayLikeObservable<T> extends Observable<T> {
 
-  private mapFn: (x: T, y: number) => T;
-
-  static create<T>(arrayLike: ArrayLike<T>, mapFn: (x: T, y: number) => T, thisArg: any, scheduler?: Scheduler): Observable<T> {
+  static create<T>(arrayLike: ArrayLike<T>, scheduler?: Scheduler): Observable<T> {
     const length = arrayLike.length;
     if (length === 0) {
       return new EmptyObservable<T>();
-    } else if (length === 1 && !mapFn) {
+    } else if (length === 1) {
       return new ScalarObservable<T>(<any>arrayLike[0], scheduler);
     } else {
-      return new ArrayLikeObservable(arrayLike, mapFn, thisArg, scheduler);
+      return new ArrayLikeObservable(arrayLike, scheduler);
     }
   }
 
   static dispatch(state: any) {
-    const { arrayLike, index, length, mapFn, subscriber } = state;
+    const { arrayLike, index, length, subscriber } = state;
 
     if (subscriber.closed) {
       return;
@@ -37,8 +35,7 @@ export class ArrayLikeObservable<T> extends Observable<T> {
       return;
     }
 
-    const result = mapFn ? mapFn(arrayLike[index], index) : arrayLike[index];
-    subscriber.next(result);
+    subscriber.next(arrayLike[index]);
 
     state.index = index + 1;
 
@@ -48,30 +45,26 @@ export class ArrayLikeObservable<T> extends Observable<T> {
   // value used if Array has one value and _isScalar
   private value: any;
 
-  constructor(private arrayLike: ArrayLike<T>, mapFn: (x: T, y: number) => T, thisArg: any, private scheduler?: Scheduler) {
+  constructor(private arrayLike: ArrayLike<T>, private scheduler?: Scheduler) {
     super();
-    if (!mapFn && !scheduler && arrayLike.length === 1) {
+    if (!scheduler && arrayLike.length === 1) {
       this._isScalar = true;
       this.value = arrayLike[0];
     }
-    if (mapFn) {
-      this.mapFn = mapFn.bind(thisArg);
-    }
   }
 
   protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
     let index = 0;
-    const { arrayLike, mapFn, scheduler } = this;
+    const { arrayLike, scheduler } = this;
     const length = arrayLike.length;
 
     if (scheduler) {
       return scheduler.schedule(ArrayLikeObservable.dispatch, 0, {
-        arrayLike, index, length, mapFn, subscriber
+        arrayLike, index, length, subscriber
       });
     } else {
       for (let i = 0; i < length && !subscriber.closed; i++) {
-        const result = mapFn ? mapFn(arrayLike[i], i) : arrayLike[i];
-        subscriber.next(result);
+        subscriber.next(arrayLike[i]);
       }
       subscriber.complete();
     }
diff --git a/src/observable/ArrayObservable.ts b/src/observable/ArrayObservable.ts
index 144659ea3b..d25600d1af 100644
--- a/src/observable/ArrayObservable.ts
+++ b/src/observable/ArrayObservable.ts
@@ -101,7 +101,7 @@ export class ArrayObservable<T> extends Observable<T> {
   // value used if Array has one value and _isScalar
   value: any;
 
-  constructor(public array: T[], public scheduler?: Scheduler) {
+  constructor(private array: T[], private scheduler?: Scheduler) {
     super();
     if (!scheduler && array.length === 1) {
       this._isScalar = true;
diff --git a/src/observable/FromObservable.ts b/src/observable/FromObservable.ts
index ebaf96a56f..8b8e6d47f3 100644
--- a/src/observable/FromObservable.ts
+++ b/src/observable/FromObservable.ts
@@ -1,7 +1,5 @@
 import {isArray} from '../util/isArray';
-import {isFunction} from '../util/isFunction';
 import {isPromise} from '../util/isPromise';
-import {isScheduler} from '../util/isScheduler';
 import {PromiseObservable} from './PromiseObservable';
 import {IteratorObservable} from'./IteratorObservable';
 import {ArrayObservable} from './ArrayObservable';
@@ -22,12 +20,12 @@ const isArrayLike = (<T>(x: any): x is ArrayLike<T> => x && typeof x.length ===
  * @hide true
  */
 export class FromObservable<T> extends Observable<T> {
-  constructor(private ish: ObservableInput<T>, private scheduler: Scheduler) {
+  constructor(private ish: ObservableInput<T>, private scheduler?: Scheduler) {
     super(null);
   }
 
   static create<T>(ish: ObservableInput<T>, scheduler?: Scheduler): Observable<T>;
-  static create<T, R>(ish: ArrayLike<T>, mapFn: (x: any, y: number) => R, thisArg?: any, scheduler?: Scheduler): Observable<R>;
+  static create<T, R>(ish: ArrayLike<T>, scheduler?: Scheduler): Observable<R>;
 
   /**
    * Creates an Observable from an Array, an array-like object, a Promise, an
@@ -71,11 +69,6 @@ export class FromObservable<T> extends Observable<T> {
    * @param {ObservableInput<T>} ish A subscribable object, a Promise, an
    * Observable-like, an Array, an iterable or an array-like object to be
    * converted.
-   * @param {function(x: any, i: number): T} [mapFn] A "map" function to call
-   * when converting array-like objects, where `x` is a value from the
-   * array-like and `i` is the index of that value in the sequence.
-   * @param {any} [thisArg] The context object to use when calling the `mapFn`,
-   * if provided.
    * @param {Scheduler} [scheduler] The scheduler on which to schedule the
    * emissions of values.
    * @return {Observable<T>} The Observable whose values are originally from the
@@ -84,19 +77,7 @@ export class FromObservable<T> extends Observable<T> {
    * @name from
    * @owner Observable
    */
-  static create<T>(ish: ObservableInput<T>,
-                   mapFnOrScheduler?: Scheduler | ((x: any, y: number) => T),
-                   thisArg?: any,
-                   lastScheduler?: Scheduler): Observable<T> {
-    let scheduler: Scheduler = null;
-    let mapFn: (x: any, i: number) => T = null;
-    if (isFunction(mapFnOrScheduler)) {
-      scheduler = lastScheduler || null;
-      mapFn = <(x: any, i: number) => T> mapFnOrScheduler;
-    } else if (isScheduler(scheduler)) {
-      scheduler = <Scheduler> mapFnOrScheduler;
-    }
-
+  static create<T>(ish: ObservableInput<T>, scheduler?: Scheduler): Observable<T> {
     if (ish != null) {
       if (typeof ish[$$observable] === 'function') {
         if (ish instanceof Observable && !scheduler) {
@@ -108,9 +89,9 @@ export class FromObservable<T> extends Observable<T> {
       } else if (isPromise(ish)) {
         return new PromiseObservable<T>(ish, scheduler);
       } else if (typeof ish[$$iterator] === 'function' || typeof ish === 'string') {
-        return new IteratorObservable<T>(<any>ish, null, null, scheduler);
+        return new IteratorObservable<T>(ish, scheduler);
       } else if (isArrayLike(ish)) {
-        return new ArrayLikeObservable(ish, mapFn, thisArg, scheduler);
+        return new ArrayLikeObservable(ish, scheduler);
       }
     }
 
diff --git a/src/observable/IteratorObservable.ts b/src/observable/IteratorObservable.ts
index f9a5f8d7d7..f6e4b131ed 100644
--- a/src/observable/IteratorObservable.ts
+++ b/src/observable/IteratorObservable.ts
@@ -1,11 +1,7 @@
 import {root} from '../util/root';
-import {isObject} from '../util/isObject';
-import {tryCatch} from '../util/tryCatch';
 import {Scheduler} from '../Scheduler';
 import {Observable} from '../Observable';
-import {isFunction} from '../util/isFunction';
 import {$$iterator} from '../symbol/iterator';
-import {errorObject} from '../util/errorObject';
 import {TeardownLogic} from '../Subscription';
 import {Subscriber} from '../Subscriber';
 
@@ -17,16 +13,13 @@ import {Subscriber} from '../Subscriber';
 export class IteratorObservable<T> extends Observable<T> {
   private iterator: any;
 
-  static create<T>(iterator: any,
-                   project?: ((x?: any, i?: number) => T) | any,
-                   thisArg?: any | Scheduler,
-                   scheduler?: Scheduler) {
-    return new IteratorObservable(iterator, project, thisArg, scheduler);
+  static create<T>(iterator: any, scheduler?: Scheduler) {
+    return new IteratorObservable(iterator, scheduler);
   }
 
   static dispatch(state: any) {
 
-    const { index, hasError, thisArg, project, iterator, subscriber } = state;
+    const { index, hasError, iterator, subscriber } = state;
 
     if (hasError) {
       subscriber.error(state.error);
@@ -34,25 +27,13 @@ export class IteratorObservable<T> extends Observable<T> {
     }
 
     let result = iterator.next();
-
     if (result.done) {
       subscriber.complete();
       return;
     }
 
-    if (project) {
-      result = tryCatch(project).call(thisArg, result.value, index);
-      if (result === errorObject) {
-        state.error = errorObject.e;
-        state.hasError = true;
-      } else {
-        subscriber.next(result);
-        state.index = index + 1;
-      }
-    } else {
-      subscriber.next(result.value);
-      state.index = index + 1;
-    }
+    subscriber.next(result.value);
+    state.index = index + 1;
 
     if (subscriber.closed) {
       return;
@@ -61,42 +42,24 @@ export class IteratorObservable<T> extends Observable<T> {
     (<any> this).schedule(state);
   }
 
-  private thisArg: any;
-  private project: (x?: any, i?: number) => T;
-  private scheduler: Scheduler;
-
-  constructor(iterator: any,
-              project?: ((x?: any, i?: number) => T) | any,
-              thisArg?: any | Scheduler,
-              scheduler?: Scheduler) {
+  constructor(iterator: any, private scheduler?: Scheduler) {
     super();
 
     if (iterator == null) {
       throw new Error('iterator cannot be null.');
     }
 
-    if (isObject(project)) {
-      this.thisArg = project;
-      this.scheduler = thisArg;
-    } else if (isFunction(project)) {
-      this.project = project;
-      this.thisArg = thisArg;
-      this.scheduler = scheduler;
-    } else if (project != null) {
-      throw new Error('when provided, `project` must be a function.');
-    }
-
     this.iterator = getIterator(iterator);
   }
 
   protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
 
     let index = 0;
-    const { iterator, project, thisArg, scheduler } = this;
+    const { iterator, scheduler } = this;
 
     if (scheduler) {
       return scheduler.schedule(IteratorObservable.dispatch, 0, {
-        index, thisArg, project, iterator, subscriber
+        index, iterator, subscriber
       });
     } else {
       do {
@@ -104,13 +67,6 @@ export class IteratorObservable<T> extends Observable<T> {
         if (result.done) {
           subscriber.complete();
           break;
-        } else if (project) {
-          result = tryCatch(project).call(thisArg, result.value, index++);
-          if (result === errorObject) {
-            subscriber.error(errorObject.e);
-            break;
-          }
-          subscriber.next(result);
         } else {
           subscriber.next(result.value);
         }
diff --git a/src/observable/PromiseObservable.ts b/src/observable/PromiseObservable.ts
index 8b2a0ea523..e7b4596e28 100644
--- a/src/observable/PromiseObservable.ts
+++ b/src/observable/PromiseObservable.ts
@@ -39,11 +39,11 @@ export class PromiseObservable<T> extends Observable<T> {
    * @name fromPromise
    * @owner Observable
    */
-  static create<T>(promise: Promise<T>, scheduler: Scheduler = null): Observable<T> {
+  static create<T>(promise: Promise<T>, scheduler?: Scheduler): Observable<T> {
     return new PromiseObservable(promise, scheduler);
   }
 
-  constructor(private promise: Promise<T>, public scheduler: Scheduler = null) {
+  constructor(private promise: Promise<T>, private scheduler?: Scheduler) {
     super();
   }