Reduce logs as array, but erroring as object

[rohitsodhia]

RxJS version:
5.1.0

Code to reproduce:

this.searchSubscription = this.filtersSubject
  .takeLast(2)
  .reduce((acc, cur) => {
    console.log(acc);
    acc.push(cur);
    return acc;
  }, [])
  .debounceTime(1000)
  .subscribe(x => this.emitFilters());

Error:
Code fails to compile because error claiming acc is an object (thus, no push method), even though the console.log shows acc to be an array.

Additional information:
I was told by this StackOverflow answer that this is a bug with RxJS? If I'm wrong, please ignore.

[trxcllnt]

pinging our resident typings police @kwonoj @david-driscoll

from the StackOverflow answer:

Your code is correct but there is a bug in rxjs5 that is preventing it from type checking.

Looking at the source code of reduce we see the following signature

export function reduce<T>(this: Observable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable<T>;

export function reduce<T>(this: Observable<T>, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable<T[]>;

export function reduce<T, R>(this: Observable<T>, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable<R>;

When writing overloads in TypeScript it is necessary to order them from greatest to least specificity with respect to their types including their type arguments. Is it because TypeScript intentionally picks the first matching overload. The last declaration of the overload set actually needs to come first.

[kwonoj]

So this is dupe to #2339?

[rohitsodhia]

Yah, the gentleman who answered my q also put up a report it seems. Close whichever is fit :)

[aluanhaddad]

@rohitsodhia, @kwonoj I apologize for the duplicate. I wanted to make sure it got reported.

[jayphelps]

@aluanhaddad @rohitsodhia I'm not able to reproduce this: Playground

Is there something else besides just using reduce that is triggering the incorrect override to be selected?

[aluanhaddad]

@jayphelps Here is a reproduction: Playground.

For reference, here is the triggering snippet

class Observable<T> {
  reduce<T>(this: Observable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable<T>;
  reduce<T>(this: Observable<T>, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable<T[]>;
  reduce<T, R>(this: Observable<T>, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable<R>;
  reduce<T, R>(this: Observable<T>, accumulator: (acc: R, value: T, index?: number) => R, seed?: R): Observable<R> { return new Observable();}
}

let o: Observable<number>;
o.reduce((acc, cur) => {
  console.log(acc);
  acc.push(cur.toString()); // error argument of type 'string' is not assignable to parameter of type 'number';
  return acc;
}, []);

Correcting the order of the overloads fixes this, giving acc the inferred type any[] which matches the behavior of the declarations for Array.prototype.reduce in lib.d.ts. While any is not desirable, the compiler cannot infer better without a type annotation, but the current declarations, by introducing an additional type parameter, clearly want to allow the seed to be of a different type (reduce is pretty limited if it cannot be).

Also note that the overload taking a seed of type T[] is unnecessary as its usecase is fully covered when the overload taking type arguments T and R is actually used which it currently never is.
Edit:
While it is indeed unnecessary, it does provide slightly improved type inference for the case when seed is T[] for some Observable<T>, and does not harm.

[WiseBird]

@aluanhaddad Hello, sorry for bothering you but could you give me a small explanation. Currently code snipped like:

import {Observable} from 'rxjs';

let o: Observable<number>;
o.reduce((acc, cur) => {
    console.log(acc);
    acc.push(cur.toString());
    return acc;
}, []);

produces the same error: TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

Is it expected? By discussion I expected that after declarations rearranging it should go away.

Moreover, test case should accept R typed reducers when R is assignable to T added in the PR causes multiple TS2339: Property 'a' does not exist on type '{}' errors.

[aluanhaddad]

That test was against an old TypeScript 2.2 IIRC. Also I think the signature of Array.prototype.push has been revised substantially and that these tests need to be looked over.

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.