pairs observable static function does not infers correctly

[dkosasih]

Bug Report

Current Behavior
pairs observable is incorrectly inferred. With the example below the type infers as Observable<[string, {}]>

var obj = {
  foo: 1,
  bar: 2,
  baz: 3
};

var source = pairs(obj);

Expected behavior
It should infer `Observable<[string, number]>

Environment

• RxJS version: Latest (6.3.3)

[jgbpercy]

Had a bit of a play with this over my lunch break... It would be possible to add an overload to pairs with this signature:

export function pairs<T>(obj: T, scheduler?: SchedulerLike): Observable<[string, T[keyof T]]>;

This issue with this is that T[keyof T] gives you a union type over all types of properties of T, not just the enumerable, own properties that pairs actually returns. Of course, the more things in a union type the less you can do with it, so I think from a soundness point of view it's ok, but if you try passing an array into that signature you don't exactly get a friendly type.

I don't think there's a way for TS to do something similar to keyof T but only return keys of enumerable/own properties - please let me know if I'm wrong!

The following two overloads cover arrays and "plain" objects (like the one in your example):

export function pairs<T>(obj: { [key: string]: T }, scheduler?: SchedulerLike): Observable<[string, T]>;
export function pairs<T>(obj: T[], scheduler?: SchedulerLike): Observable<[string, T]>;

Maybe these on their own would be fine? But the signature with [key: string]: T falls over as soon as you do something like:

interface Base {
  thing: number;
}

interface Child extends Base {
  otherThing: string[];
}

const child: Child = {
  thing: 1,
  otherThing: ['yes', 'yeah']
}

const source = pairs(child); // Types to Observable<[string, {}]>

// Even though the identical-at-runtime
const otherSource = pairs({
  thing: 1,
  otherThing: ['yes', 'yeah'],
});
// Types to Observable<[string, number | string[]]> correctly

(I don't totally understand the reason why, and whether this is specifically to do with inheritance or not?)

So maybe the overloads could be this (the two simple ones first, followed by the more general one):

export function pairs<T>(obj: { [key: string]: T }, scheduler?: SchedulerLike): Observable<[string, T]>;
export function pairs<T>(obj: T[], scheduler?: SchedulerLike): Observable<[string, T]>;
export function pairs<T>(obj: T, scheduler?: SchedulerLike): Observable<[string, T[keyof T]]>;

That way you only fall back to the T[keyof T] overload if you're not passing an array or plain object.

I don't know what the standard is on typing to unions that are less specific than they "should be"? I'm not hugely read up on type theory, but my understanding is that the {} type you get back without the third overload is basically the same as the union of all types, so typing to some more specific union, that still includes all the correct possible types, and some extras, is still sound and at least in some sense better :)

Happy to put in a PR with d.ts tests if people think any/all of the above overloads are an improvement?

[jgbpercy]

Oh and @dkosasih or anyone else that comes across this, right now it looks like the current signature for pairs has no possibility for inference based on arguments, so in 6.3.3 you always need to specify the type param (in your case pairs<number>(obj))

[dkosasih]

My understanding is that it should infer without explicitly define the type. It should be able to just infer.
About the overloads, it looks good to me. But, maybe @benlesh or @cartant would have better perspective on this.

[BioPhoton]

@cartant Is this now with Typescript 3+ possible?
If yes let's comment the next steps. If no let's close this issue

[cartant]

Closing this because the types in v7 infer correctly:

var obj = {
  foo: 1,
  bar: 2,
  baz: 3
};
var source = pairs(obj); // Observable<["foo" | "bar" | "baz", number]>

And because pairs is now deprecated:

rxjs/src/internal/observable/pairs.ts

Lines 9 to 12 in 4805a7f

	/**
	* @deprecated To be removed in version 8. Use `from(Object.entries(obj))` instead.
	*/
	export function pairs<O extends Record<string, unknown>>(obj: O, scheduler?: SchedulerLike): Observable<[keyof O, O[keyof O]]>;