Mapped tuples types iterates over all properties

TypeScript Version: 3.2.0-dev.20181019

Search Terms: mapped tuples reify

Code

type Foo = ['a', 'b'];
interface Bar
{
	a: string;
	b: number;
}

type Baz = { [K in keyof Foo]: Bar[Foo[K]]; }; // Expected Baz to be [string, number]

Expected behavior: Baz should be [string, number]

Actual behavior: Type ‘[“a”, “b”][K]’ cannot be used to index type ‘Bar’.

Playground Link: https://www.typescriptlang.org/play/index.html#src=type Foo %3D [‘a’%2C ‘b’]%3B interface Bar { a%3A string%3B b%3A number%3B } type Baz %3D { [K in keyof Foo]%3A Bar[Foo[K]]%3B }%3B %2F%2F Expected Baz to be [string%2C number] type WorkingBaz %3D { [K in Exclude<keyof Foo%2C keyof any[]>]%3A Foo[K] extends keyof Bar %3F Bar[Foo[K]] %3A never%3B } %26 { length%3A Foo[‘length’]%3B } %26 any[]%3B

Related Issues: https://github.com/Microsoft/TypeScript/issues/25947

Given the Mapped tuple types feature (#25947). I’d expect the code above to work cleanly.

However, I still need to do:

type WorkingBaz = { [K in Exclude<keyof Foo, keyof any[]>]: Foo[K] extends keyof Bar ? Bar[Foo[K]] : never; } & { length: Foo['length']; } & any[];

To have an equivalent type. As far as I understand, the “K” in a mapped type on a tuple should iterate only on numeric keys of this tuple. Therefore, Foo[K] should always be a valid key for Bar…

[weswigham]

This is because, despite mapped types not behaving as such, keyof ["some", "tuple"] still returns 0 | 1 | "length" | ... | "whatever" instead of 0 | 1.

[ksaldana1]

@lemoinem You can get your current example to narrow correctly and avoid the behavior @weswigham mentioned with a couple of helper conditional types. Note: this comes with some not so great drawbacks… You lose all array prototype methods and properties, which for my current use case–messing with React hooks–that tradeoff isn’t the worst thing in the world.

export type ArrayKeys = keyof any[];
export type Indices<T> = Exclude<keyof T, ArrayKeys>;

type Foo = ['a', 'b'];

interface Bar {
  a: string;
  b: number;
}

type Baz = { [K in Indices<Foo>]: Bar[Foo[K]] }; // type is { "0": string, "1": number }

The way this type ends up formatting isn’t the greatest, but it ultimately maps to some of your desired outcomes. I am having issues around some constructs I thought would work, similar to @phiresky 's examples. I will get some better examples together and document those, but for now just wanted to provide a bit of a workaround.