feat(distinctUntilChanged): remove thisArg

relates to #878

Author: kwonoj

src/CoreOperators.ts

@@ -24,7 +24,7 @@ export interface CoreOperators<T> {
   debounceTime?: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
   defaultIfEmpty?: <R>(defaultValue?: T | R) => Observable<T> | Observable<R>;
   delay?: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  distinctUntilChanged?: (compare?: (x: T, y: T) => boolean, thisArg?: any) => Observable<T>;
+  distinctUntilChanged?: (compare?: (x: T, y: T) => boolean) => Observable<T>;
   do?: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
   expand?: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
   filter?: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;

src/Observable.ts

@@ -186,7 +186,7 @@ export class Observable<T> implements CoreOperators<T>  {
   debounceTime: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
   defaultIfEmpty: <R>(defaultValue?: T | R) => Observable<T> | Observable<R>;
   delay: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  distinctUntilChanged: (compare?: (x: T, y: T) => boolean, thisArg?: any) => Observable<T>;
+  distinctUntilChanged: (compare?: (x: T, y: T) => boolean) => Observable<T>;
   do: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
   expand: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
   filter: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;

src/operator/distinctUntilChanged.ts

@@ -2,16 +2,13 @@ import {Operator} from '../Operator';
 import {Subscriber} from '../Subscriber';
 import {tryCatch} from '../util/tryCatch';
 import {errorObject} from '../util/errorObject';
-import {bindCallback} from '../util/bindCallback';
 
-export function distinctUntilChanged<T>(compare?: (x: T, y: T) => boolean, thisArg?: any) {
-  return this.lift(new DistinctUntilChangedOperator(thisArg ?
-    <(x: T, y: T) => boolean> bindCallback(compare, thisArg, 2) :
-    compare));
+export function distinctUntilChanged<T>(compare?: (x: T, y: T) => boolean) {
+  return this.lift(new DistinctUntilChangedOperator(compare));
 }
 
 class DistinctUntilChangedOperator<T, R> implements Operator<T, R> {
-  constructor(private compare?: (x: T, y: T) => boolean) {
+  constructor(private compare: (x: T, y: T) => boolean) {
   }
 
   call(subscriber: Subscriber<T>): Subscriber<T> {
@@ -23,7 +20,7 @@ class DistinctUntilChangedSubscriber<T> extends Subscriber<T> {
   private value: T;
   private hasValue: boolean = false;
 
-  constructor(destination: Subscriber<T>, compare?: (x: T, y: T) => boolean) {
+  constructor(destination: Subscriber<T>, compare: (x: T, y: T) => boolean) {
     super(destination);
     if (typeof compare === 'function') {
       this.compare = compare;