refactor(switchMap): rename switchLatest to switchMap

CONTRIBUTION.md

@@ -216,7 +216,7 @@ Must be one of the following:
 
 ### Scope
 The scope could be anything specifying place of the commit change. For example
-`Observable`, `Subject`, `switchLatest`, etc.
+`Observable`, `Subject`, `switchMap`, etc.
 
 ### Subject
 The subject contains succinct description of the change:

doc/index.md

@@ -73,8 +73,8 @@
 - [startWith](function/index.html#static-function-startWith)
 - [subscribeOn](function/index.html#static-function-subscribeOn)
 - [switch](function/index.html#static-function-switch)
-- [switchLatest](function/index.html#static-function-switchLatest)
-- [switchLatestTo](function/index.html#static-function-switchLatestTo)
+- [switchMap](function/index.html#static-function-switchMap)
+- [switchMapTo](function/index.html#static-function-switchMapTo)
 - [take](function/index.html#static-function-take)
 - [takeUntil](function/index.html#static-function-takeUntil)
 - [throttle](function/index.html#static-function-throttle)

spec/operators/switchLatest-spec.js → spec/operators/switchMap-spec.js

@@ -3,11 +3,11 @@ var Rx = require('../../dist/cjs/Rx');
 var Observable = Rx.Observable;
 var immediateScheduler = Rx.Scheduler.immediate;
 
-describe('Observable.prototype.switchLatest()', function () {
+describe('Observable.prototype.switchMap()', function () {
   it("should switch with a selector function", function (done) {
     var a = Observable.of(1, 2, 3);
     var expected = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'a3', 'b3', 'c3'];
-    a.switchLatest(function(x) {
+    a.switchMap(function(x) {
       return Observable.of('a' + x, 'b' + x, 'c' + x);
     }).subscribe(function (x) {
       expect(x).toBe(expected.shift());
@@ -17,7 +17,7 @@ describe('Observable.prototype.switchLatest()', function () {
   it('should unsub inner observables', function(){
     var unsubbed = [];
 
-    Observable.of('a', 'b').switchLatest(function(x) {
+    Observable.of('a', 'b').switchMap(function(x) {
       return Observable.create(function(subscriber) {
         subscriber.complete();
         return function() {
@@ -37,7 +37,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected);    
   });
@@ -50,7 +50,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected);    
   });
@@ -63,7 +63,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected);    
   });
@@ -76,7 +76,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected);    
   });
@@ -89,7 +89,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected);    
   });
@@ -102,7 +102,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected, undefined, new Error('sad'));    
   });
@@ -115,31 +115,31 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x, y: y };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected, undefined, new Error('sad'));    
   });
 
   it('should handle outer empty', function (){
     var e1 = Observable.empty();
     var expected = '|';
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return Observable.of(value);
     })).toBe(expected);
   });
 
   it('should handle outer never', function (){
     var e1 = Observable.never();
     var expected = '----';
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return Observable.of(value);
     })).toBe(expected);
   });
 
   it('should handle outer throw', function (){
     var e1 = Observable.throw(new Error('wah'));
     var expected = '#';
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return Observable.of(value);
     })).toBe(expected, undefined, new Error('wah'));
   });
@@ -151,7 +151,7 @@ describe('Observable.prototype.switchLatest()', function () {
 
     var observableLookup = { x: x };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     })).toBe(expected, undefined, new Error('boo-hoo'));    
   });
@@ -174,7 +174,7 @@ describe('Observable.prototype.switchLatest()', function () {
       i: ['i', 'y', 3, 1]
     };
 
-    expectObservable(e1.switchLatest(function(value) {
+    expectObservable(e1.switchMap(function(value) {
       return observableLookup[value];
     }, function(innerValue, outerValue, innerIndex, outerIndex) {
       return [innerValue, outerValue, innerIndex, outerIndex];

src/Observable.ts

@@ -173,9 +173,9 @@ export default class Observable<T>  {
   delay: <T>(delay: number, scheduler?: Scheduler) => Observable<T>;
 
   switch: <R>() => Observable<R>;
-  switchLatest: <R>(project: ((x: T, ix: number) => Observable<any>),
+  switchMap: <R>(project: ((x: T, ix: number) => Observable<any>),
                     projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  switchLatestTo: <R>(observable: Observable<any>,
+  switchMapTo: <R>(observable: Observable<any>,
                       projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
 
   static combineLatest: <T>(...observables: (Observable<any> | ((...values: Array<any>) => T)) []) => Observable<T>;

src/Rx.ts

@@ -67,8 +67,8 @@ import mergeAll from './operators/mergeAll';
 import flatMap from './operators/flatMap';
 import flatMapTo from './operators/flatMapTo';
 import _switch from './operators/switch';
-import switchLatest from './operators/switchLatest';
-import switchLatestTo from './operators/switchLatestTo';
+import switchMap from './operators/switchMap';
+import switchMapTo from './operators/switchMapTo';
 import expand from './operators/expand';
 
 Observable.merge = merge;
@@ -77,8 +77,8 @@ observableProto.mergeAll = mergeAll;
 observableProto.flatMap = flatMap;
 observableProto.flatMapTo = flatMapTo;
 observableProto.switch = _switch;
-observableProto.switchLatest = switchLatest;
-observableProto.switchLatestTo = switchLatestTo;
+observableProto.switchMap = switchMap;
+observableProto.switchMapTo = switchMapTo;
 observableProto.expand = expand;
 
 import _do from './operators/do';

src/operators/switchLatest.ts → src/operators/switchMap.ts

@@ -7,22 +7,22 @@ import tryCatch from '../util/tryCatch';
 import { errorObject } from '../util/errorObject';
 import { FlatMapSubscriber } from './flatMap-support';
 
-export default function switchLatest<T, R, R2>(project: (value: T, index: number) => Observable<R>,
+export default function switchMap<T, R, R2>(project: (value: T, index: number) => Observable<R>,
                                            resultSelector?: (innerValue: R, outerValue: T, innerIndex: number, outerIndex: number) => R2): Observable<R>{
-  return this.lift(new SwitchLatestOperator(project, resultSelector));
+  return this.lift(new SwitchMapOperator(project, resultSelector));
 }
 
-class SwitchLatestOperator<T, R, R2> implements Operator<T, R> {
+class SwitchMapOperator<T, R, R2> implements Operator<T, R> {
   constructor(private project: (value: T, index: number) => Observable<R>,
               private resultSelector?: (innerValue: R, outerValue: T, innerIndex: number, outerIndex: number) => R2) {
   }
 
   call(subscriber: Subscriber<R>): Subscriber<T> {
-    return new SwitchLatestSubscriber(subscriber, this.project, this.resultSelector);
+    return new SwitchMapSubscriber(subscriber, this.project, this.resultSelector);
   }
 }
 
-class SwitchLatestSubscriber<T, R, R2> extends Subscriber<T> {
+class SwitchMapSubscriber<T, R, R2> extends Subscriber<T> {
 
   private innerSubscription: Subscription<T>;
   private hasCompleted = false;
@@ -45,7 +45,7 @@ class SwitchLatestSubscriber<T, R, R2> extends Subscriber<T> {
       if(innerSubscription) {
         innerSubscription.unsubscribe();
       }
-      this.add(this.innerSubscription = result.subscribe(new InnerSwitchLatestSubscriber(this, this.resultSelector, index, value)))
+      this.add(this.innerSubscription = result.subscribe(new InnerSwitchMapSubscriber(this, this.resultSelector, index, value)))
     }
   }
 
@@ -74,10 +74,10 @@ class SwitchLatestSubscriber<T, R, R2> extends Subscriber<T> {
   }
 }
 
-class InnerSwitchLatestSubscriber<T, R, R2> extends Subscriber<T> {
+class InnerSwitchMapSubscriber<T, R, R2> extends Subscriber<T> {
   private index: number = 0;
 
-  constructor(private parent: SwitchLatestSubscriber<T, R, R2>, 
+  constructor(private parent: SwitchMapSubscriber<T, R, R2>, 
     private resultSelector: (innerValue: R, outerValue: T, innerIndex: number, outerIndex: number) => R2,
     private outerIndex: number,
     private outerValue: any) {

src/operators/switchLatestTo.ts → src/operators/switchMapTo.ts

@@ -6,22 +6,22 @@ import Subscription from '../Subscription';
 
 import { FlatMapToSubscriber } from './flatMapTo-support';
 
-export default function switchLatestTo<T, R, R2>(observable: Observable<R>,
+export default function switchMapTo<T, R, R2>(observable: Observable<R>,
                                              projectResult?: (innerValue: R, outerValue: T, innerIndex: number, outerIndex: number) => R2): Observable<R2> {
-  return this.lift(new SwitchLatestToOperator(observable, projectResult));
+  return this.lift(new SwitchMapToOperator(observable, projectResult));
 }
 
-class SwitchLatestToOperator<T, R, R2> implements Operator<T, R> {
+class SwitchMapToOperator<T, R, R2> implements Operator<T, R> {
   constructor(private observable: Observable<R>,
               private resultSelector?: (innerValue: R, outerValue: T, innerIndex: number, outerIndex: number) => R2) {
   }
 
   call(subscriber: Subscriber<R>): Subscriber<T> {
-    return new SwitchLatestToSubscriber(subscriber, this.observable, this.resultSelector);
+    return new SwitchMapToSubscriber(subscriber, this.observable, this.resultSelector);
   }
 }
 
-class SwitchLatestToSubscriber<T, R, R2> extends FlatMapToSubscriber<T, R, R2> {
+class SwitchMapToSubscriber<T, R, R2> extends FlatMapToSubscriber<T, R, R2> {
 
   innerSubscription: Subscription<T>;