From f03e7907fc7ff848a4ab41092739a856a8e6d5cf Mon Sep 17 00:00:00 2001
From: Ben Lesh <ben@benlesh.com>
Date: Tue, 25 Sep 2018 13:42:08 -0700
Subject: [PATCH] fix(TypeScript): ensure RxJS builds with TS@next as well

---
 spec-dtslint/util/pipe-spec.ts   | 23 +++++++++++++++++++----
 spec/operators/zipAll-spec.ts    |  7 +++----
 src/internal/operators/reduce.ts |  7 ++++---
 src/internal/util/pipe.ts        | 25 +++++++++++--------------
 4 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/spec-dtslint/util/pipe-spec.ts b/spec-dtslint/util/pipe-spec.ts
index b715aea054..4661852ed9 100644
--- a/spec-dtslint/util/pipe-spec.ts
+++ b/spec-dtslint/util/pipe-spec.ts
@@ -84,14 +84,29 @@ it('should enforce types for the 9th argument', () => {
   const o = pipe(a('0', '1'), a('1', '2'), a('2', '3'), a('3', '4'), a('4', '5'), a('5', '6'), a('6', '7'), a('7', '8'), a('#', '9')); // $ExpectError
 });
 
-it('should return generic OperatorFunction', () => {
+it('should return generic OperatorFunction 1', () => {
+  const customOperator = <T>(p: T) => (a: Observable<T>) => a;
+
+  const staticPipe = pipe(customOperator('infer'));
+  const o = of('foo').pipe(staticPipe); // $ExpectType Observable<string>
+});
+
+it('should return generic OperatorFunction 2', () => {
   const customOperator = <T>() => (a: Observable<T>) => a;
 
-  const staticPipe = pipe(customOperator());
+  const staticPipe = pipe(customOperator<string>());
   const o = of('foo').pipe(staticPipe); // $ExpectType Observable<string>
 });
 
+it('should return generic OperatorFunction 3', () => {
+  const customOperator = <T>() => (a: Observable<T>) => a;
+
+  // type can't be possibly be inferred here, so it's {} instead of T.
+  const staticPipe = pipe(customOperator());
+  const o = of('foo').pipe(staticPipe); // $ExpectType Observable<{}>
+});
+
 it('should return generic function', () => {
-  const func = pipe((value: string) => value);
-  const value = func("foo"); // $ExpectType "foo"
+  const func = pipe((value: string) => value, (value: string) => value + value);
+  const value = func("foo"); // $ExpectType string
 });
diff --git a/spec/operators/zipAll-spec.ts b/spec/operators/zipAll-spec.ts
index 6b8d0af1c1..52a3c56f09 100644
--- a/spec/operators/zipAll-spec.ts
+++ b/spec/operators/zipAll-spec.ts
@@ -35,11 +35,10 @@ describe('zipAll operator', () => {
   it('should take all observables from the source and zip them', (done) => {
     const expected = ['a1', 'b2', 'c3'];
     let i = 0;
-    of(
+    const source = of(
       of('a', 'b', 'c'),
       of(1, 2, 3)
-    )
-    .pipe(zipAll((a, b) => String(a) + String(b)))
+    ).pipe(zipAll((a: string, b: number) => a + b))
     .subscribe((x) => {
       expect(x).to.equal(expected[i++]);
     }, null, done);
@@ -378,7 +377,7 @@ describe('zipAll operator', () => {
       of('a', 'b', 'c'),
       of(1, 2)
     )
-    .pipe(zipAll((a, b) => String(a) + String(b)))
+    .pipe(zipAll((a: string, b: number) => a + b))
     .subscribe((x) => {
       expect(x).to.equal(expected[i++]);
     }, null, done);
diff --git a/src/internal/operators/reduce.ts b/src/internal/operators/reduce.ts
index 9820dd47b7..a627dfb4ef 100644
--- a/src/internal/operators/reduce.ts
+++ b/src/internal/operators/reduce.ts
@@ -71,8 +71,9 @@ export function reduce<T, R>(accumulator: (acc: R, value: T, index?: number) =>
     };
   }
   return function reduceOperatorFunction(source: Observable<T>): Observable<R> {
-    return pipe(scan<T, T | R>((acc, value, index) => {
-      return accumulator(<R>acc, value, index + 1);
-    }), takeLast(1))(source) as Observable<R>;
+    return pipe(
+      scan((acc: R, value: T, index: number): R => accumulator(acc, value, index + 1)),
+      takeLast(1),
+    )(source);
   };
 }
diff --git a/src/internal/util/pipe.ts b/src/internal/util/pipe.ts
index 14c92cb976..206f566d82 100644
--- a/src/internal/util/pipe.ts
+++ b/src/internal/util/pipe.ts
@@ -1,21 +1,18 @@
 import { noop } from './noop';
-import { UnaryFunction, MonoTypeOperatorFunction } from '../types';
-import { Observable } from '../Observable';
+import { UnaryFunction } from '../types';
 
 /* tslint:disable:max-line-length */
 export function pipe<T>(): UnaryFunction<T, T>;
-export function pipe<T>(...operators: MonoTypeOperatorFunction<T>[]): <R extends T>(source: Observable<R>) => Observable<R>;
-export function pipe<T>(...operators: UnaryFunction<T, T>[]): <R extends T>(source: R) => R;
-export function pipe<T, A>(op1: UnaryFunction<T, A>): UnaryFunction<T, A>;
-export function pipe<T, A, B>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>): UnaryFunction<T, B>;
-export function pipe<T, A, B, C>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>): UnaryFunction<T, C>;
-export function pipe<T, A, B, C, D>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>): UnaryFunction<T, D>;
-export function pipe<T, A, B, C, D, E>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>): UnaryFunction<T, E>;
-export function pipe<T, A, B, C, D, E, F>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>): UnaryFunction<T, F>;
-export function pipe<T, A, B, C, D, E, F, G>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>): UnaryFunction<T, G>;
-export function pipe<T, A, B, C, D, E, F, G, H>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>): UnaryFunction<T, H>;
-export function pipe<T, A, B, C, D, E, F, G, H, I>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>, op9: UnaryFunction<H, I>): UnaryFunction<T, I>;
-export function pipe<T, A, B, C, D, E, F, G, H, I>(op1: UnaryFunction<T, A>, op2: UnaryFunction<A, B>, op3: UnaryFunction<B, C>, op4: UnaryFunction<C, D>, op5: UnaryFunction<D, E>, op6: UnaryFunction<E, F>, op7: UnaryFunction<F, G>, op8: UnaryFunction<G, H>, op9: UnaryFunction<H, I>, ...operations: UnaryFunction<any, any>[]): UnaryFunction<T, {}>;
+export function pipe<T, A>(fn1: UnaryFunction<T, A>): UnaryFunction<T, A>;
+export function pipe<T, A, B>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>): UnaryFunction<T, B>;
+export function pipe<T, A, B, C>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>): UnaryFunction<T, C>;
+export function pipe<T, A, B, C, D>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>): UnaryFunction<T, D>;
+export function pipe<T, A, B, C, D, E>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>): UnaryFunction<T, E>;
+export function pipe<T, A, B, C, D, E, F>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>): UnaryFunction<T, F>;
+export function pipe<T, A, B, C, D, E, F, G>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>): UnaryFunction<T, G>;
+export function pipe<T, A, B, C, D, E, F, G, H>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>): UnaryFunction<T, H>;
+export function pipe<T, A, B, C, D, E, F, G, H, I>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>, fn9: UnaryFunction<H, I>): UnaryFunction<T, I>;
+export function pipe<T, A, B, C, D, E, F, G, H, I>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>, fn9: UnaryFunction<H, I>, ...fns: UnaryFunction<any, any>[]): UnaryFunction<T, {}>;
 /* tslint:enable:max-line-length */
 
 export function pipe(...fns: Array<UnaryFunction<any, any>>): UnaryFunction<any, any> {