Mapped tuple types don't infer as arrays in generics

[jscheiny]

TypeScript Version: 3.1.0-dev.20180802

Search Terms:

Mapped tuple type generic infer array

Code

type Element<T> = T extends Array<infer U> ? U : never;
type Mapped<T> = { [K in keyof T]: T[K] };

type F<T> = Element<Mapped<T>>;
type R1 = F<[string, number, boolean]>; // never
type R2 = Element<Mapped<[string, number, boolean]>>; // string | number | boolean

Expected behavior:

The type of R1 should be string | number | boolean.

Actual behavior:

The type of R1 is never.

[jcalz]

Yeah, this has bitten me too...

declare function acceptArray(arr: any[]): void;
declare function mapArray<T extends any[]>(arr: T): {[K in keyof T]: T[K]};
function acceptMappedArray<T extends any[]>(arr: T) {
 acceptArray(mapArray(arr)); // error! 
}

[jscheiny]

I just got a chance to try this out, and it works well in situations where the generic type parameter is unconstrained however adding a constraint to this seems to mess things up as below:

type Element<T> = T extends Array<infer U> ? U : never;
type Mapped<T> = { [K in keyof T]: T[K] };

type Unconstrained<T> = Element<Mapped<T>>;
type T1 = Unconstrained<[string, number, boolean]>; // string | number | boolean

type Constrained<T extends any[]> = Element<Mapped<T>>;
type T2 = Constrained<[string, number, boolean]>; // any

In this case, Constrained<T> seems to always return any despite its only difference from Unconstrained<T> being the extends any[] clause. It seems that the type of the constraint is important as can be seen below:

type Unconstrained<T> = Element<Mapped<T>>;
type T1 = Unconstrained<[1, 2, 3]>; // 1 | 2 | 3

type Constrained<T extends number[]> = Element<Mapped<T>>;
type T2 = Constrained<[1, 2, 3]>; // number

Should I re-open this ticket or file a new one?

[ahejlsberg]

Yes, appears we still have an issue. I will reopen.