fix(typings): remove R from Operator.call, update operators accordingly

Author: masaeedu

src/Operator.ts

@@ -1,7 +1,7 @@
 import {Subscriber} from './Subscriber';
 
 export class Operator<T, R> {
-  call<R>(subscriber: Subscriber<R>): Subscriber<T> {
+  call(subscriber: Subscriber<R>): Subscriber<T> {
     return new Subscriber<T>(subscriber);
   }
 }

src/observable/dom/WebSocketSubject.ts

@@ -61,7 +61,7 @@ export class WebSocketSubject<T> extends Subject<T> {
 
   lift<R>(operator: Operator<T, R>) {
     const sock: WebSocketSubject<T> = new WebSocketSubject(this, this.destination);
-    sock.operator = operator;
+    sock.operator = <any>operator;
     return sock;
   }
 

src/operator/defaultIfEmpty.ts

@@ -11,20 +11,20 @@ export function defaultIfEmpty<T, R>(defaultValue: R = null): Observable<T | R>
   return this.lift(new DefaultIfEmptyOperator(defaultValue));
 }
 
-class DefaultIfEmptyOperator<T, R> implements Operator<T, R> {
+class DefaultIfEmptyOperator<T, R> implements Operator<T, T | R> {
 
   constructor(private defaultValue: R) {
   }
 
-  call(subscriber: Subscriber<T>): Subscriber<T> {
+  call(subscriber: Subscriber<T | R>): Subscriber<T> {
     return new DefaultIfEmptySubscriber(subscriber, this.defaultValue);
   }
 }
 
 class DefaultIfEmptySubscriber<T, R> extends Subscriber<T> {
   private isEmpty: boolean = true;
 
-  constructor(destination: Subscriber<T>, private defaultValue: R) {
+  constructor(destination: Subscriber<T | R>, private defaultValue: R) {
     super(destination);
   }
 

src/operator/distinct.ts

@@ -16,11 +16,11 @@ import {subscribeToResult} from '../util/subscribeToResult';
  * @param {Observable} [flushes] optional Observable for flushing the internal HashSet of the operator.
  * @returns {Observable} an Observable that emits items from the source Observable with distinct values.
  */
-export function distinct<T>(compare?: (x: T, y: T) => boolean, flushes?: Observable<any>) {
+export function distinct<T>(compare?: (x: T, y: T) => boolean, flushes?: Observable<any>): Observable<T> {
   return this.lift(new DistinctOperator(compare, flushes));
 }
 
-class DistinctOperator<T, R> implements Operator<T, R> {
+class DistinctOperator<T> implements Operator<T, T> {
   constructor(private compare: (x: T, y: T) => boolean, private flushes: Observable<any>) {
   }
 

src/operator/every.ts

@@ -39,7 +39,7 @@ export function every<T>(predicate: (value: T, index: number, source: Observable
   return source.lift(new EveryOperator(predicate, thisArg, source));
 }
 
-class EveryOperator<T, R> implements Operator<T, R> {
+class EveryOperator<T, R> implements Operator<T, boolean> {
   constructor(private predicate: (value: T, index: number, source: Observable<T>) => boolean,
               private thisArg?: any,
               private source?: Observable<T>) {

src/operator/groupBy.ts

@@ -31,7 +31,7 @@ export interface RefCountSubscription {
   attemptedToUnsubscribe: boolean;
 }
 
-class GroupByOperator<T, K, R> extends Operator<T, R> {
+class GroupByOperator<T, K, R> extends Operator<T, GroupedObservable<K, R>> {
   constructor(public source: Observable<T>,
               private keySelector: (value: T) => K,
               private elementSelector?: (value: T) => R,

src/operator/inspect.ts

@@ -12,7 +12,7 @@ export function inspect<T>(durationSelector: (value: T) => Observable<any> | Pro
   return this.lift(new InspectOperator(durationSelector));
 }
 
-class InspectOperator<T, R> implements Operator<T, R> {
+class InspectOperator<T> implements Operator<T, T> {
   constructor(private durationSelector: (value: T) => Observable<any> | Promise<any>) {
   }
 

src/operator/inspectTime.ts

@@ -9,7 +9,7 @@ export function inspectTime<T>(delay: number, scheduler: Scheduler = asap): Obse
   return this.lift(new InspectTimeOperator(delay, scheduler));
 }
 
-class InspectTimeOperator<T, R> implements Operator<T, R> {
+class InspectTimeOperator<T> implements Operator<T, T> {
   constructor(private delay: number, private scheduler: Scheduler) {
   }
 

src/operator/isEmpty.ts

@@ -13,15 +13,14 @@ export function isEmpty(): Observable<boolean> {
   return this.lift(new IsEmptyOperator());
 }
 
-class IsEmptyOperator<T> implements Operator<boolean, boolean> {
-  call (observer: Subscriber<T>): Subscriber<boolean> {
+class IsEmptyOperator implements Operator<any, boolean> {
+  call (observer: Subscriber<boolean>): Subscriber<any> {
     return new IsEmptySubscriber(observer);
   }
 }
 
-class IsEmptySubscriber extends Subscriber<boolean> {
-
-  constructor(destination: Subscriber<any>) {
+class IsEmptySubscriber extends Subscriber<any> {
+  constructor(destination: Subscriber<boolean>) {
     super(destination);
   }
 

src/operator/pairwise.ts

@@ -11,12 +11,12 @@ import {Subscriber} from '../Subscriber';
  *
  * @returns {Observable<R>} an observable of pairs of values.
  */
-export function pairwise<T>(): Observable<T> {
+export function pairwise<T>(): Observable<[T, T]> {
   return this.lift(new PairwiseOperator());
 }
 
-class PairwiseOperator<T, R> implements Operator<T, R> {
-  call(subscriber: Subscriber<T>): Subscriber<T> {
+class PairwiseOperator<T> implements Operator<T, [T, T]> {
+  call(subscriber: Subscriber<[T, T]>): Subscriber<T> {
     return new PairwiseSubscriber(subscriber);
   }
 }
@@ -25,7 +25,7 @@ class PairwiseSubscriber<T> extends Subscriber<T> {
   private prev: T;
   private hasPrev: boolean = false;
 
-  constructor(destination: Subscriber<T>) {
+  constructor(destination: Subscriber<[T, T]>) {
     super(destination);
   }