Improve type inference of `pluck` operator

RxJS version: 5.4.3

Code to reproduce:

const obs = Observable.of([{ a: { b: 1 } }]);
const a = obs.pluck('a');

Expected behavior: a be of type Observable<{b: 1}>.

Actual behavior: a is of type Observable<{}>

Additional information: While I realise that I can provide the type of the return value to pluck, doing so doesn’t give me any type safety. Instead, this could be inferred, at least for an arbitrary level of nesting. Anyone who goes beyond this level of nesting wouldn’t be able to use type inference, very similarly to the current state of things.

type Pluck<T, K extends keyof T> = T[K];

export function pluck<
  T,
  P1 extends keyof T
>(
  this: Observable<T>,
  property1: P1,
): Observable<Pluck<T, P1>>;

export function pluck<
  T,
  P1 extends keyof T,
  P2 extends keyof T[P1]
>(
  this: Observable<T>,
  property1: P1,
  property2: P2,
): Observable<Pluck<Pluck<T, P1>, P2>>;

export function pluck<
  T,
  P1 extends keyof T,
  P2 extends keyof T[P1],
  P3 extends keyof T[P1][P2]
>(
  this: Observable<T>,
  property1: P1,
  property2: P2,
  property3: P3,
): Observable<Pluck<Pluck<Pluck<T, P1>, P2>, P3>>;

export function pluck<
  T,
  P1 extends keyof T,
  P2 extends keyof T[P1],
  P3 extends keyof T[P1][P2],
  P4 extends keyof T[P1][P2][P3]
>(
  this: Observable<T>,
  property1: P1,
  property2: P2,
  property3: P3,
  property4: P4,
): Observable<Pluck<Pluck<Pluck<Pluck<T, P1>, P2>, P3>, P4>>;
export function pluck<T>(
  this: Observable<T>,
  ...properties: string[]
): Observable<any> {
  return higherOrder(...properties)(this);
}

[aboyton]

Is this ready to be reopened?

[lock[bot]]

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.