Mapped tuples types iterates over all properties

[lemoinem]

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%20Foo%20%3D%20%5B'a'%2C%20'b'%5D%3B%0D%0Ainterface%20Bar%0D%0A%7B%0D%0A%09a%3A%20string%3B%0D%0A%09b%3A%20number%3B%0D%0A%7D%0D%0A%0D%0Atype%20Baz%20%3D%20%7B%20%5BK%20in%20keyof%20Foo%5D%3A%20Bar%5BFoo%5BK%5D%5D%3B%20%7D%3B%20%2F%2F%20Expected%20Baz%20to%20be%20%5Bstring%2C%20number%5D%0D%0A%0D%0Atype%20WorkingBaz%20%3D%20%7B%20%5BK%20in%20Exclude%3Ckeyof%20Foo%2C%20keyof%20any%5B%5D%3E%5D%3A%20Foo%5BK%5D%20extends%20keyof%20Bar%20%3F%20Bar%5BFoo%5BK%5D%5D%20%3A%20never%3B%20%7D%20%26%20%7B%20length%3A%20Foo%5B'length'%5D%3B%20%7D%20%26%20any%5B%5D%3B

Related 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.

[nabbydude]

I wouldnt mind a fix for this as well. I've been encountering similar issues, but here's how I've been working around it for anyone else with this problem: (my code generalized below with Boxes)

interface Box<T> {
  value: T;
}

type UnBox<T extends Box<unknown>> = T extends Box<infer U> ? U : never;

type UnBoxTuple<T extends Box<unknown>[]> = {
  [P in keyof T]: UnBox<T[P]>;
};

Above code complains that T[P] does not satisfy the constraint Box<unknown>. My current fix has been just to manually narrow the type with a conditional like so: (Edit: looks like this format is required for using mapped tuples like this, #27351)

type UnBoxTuple<T extends Box<unknown>[]> = {
  [P in keyof T]: T[P] extends T[number] ? UnBox<T[P]> : never;
};

Trying to apply the same to Mathieu Lemoine (@lemoinem)'s example didn't work at first. It seems like the mapped tuple special-case only applies to generics (try the following in ts 3.1.3 to see what I mean):

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

type GenericTupleIdentity<T extends unknown[]> = { [K in keyof T]: T[K] };
type FooIdentity = { [K in keyof Foo]: Foo[K] }

type GenericTupleIdentityTest = GenericTupleIdentity<Foo> // ["a", "b"]
type FooIdentityTest = FooIdentity // a Foo-like object no longer recognised as a tuple

Not sure if this inconsistency is intended or not. Abstracting-out Foo and Bar and adding a manual type-narrower gets us:

type Bazify<B, F extends (keyof B)[]> = {
  [K in keyof F]: F[K] extends F[number] ? B[F[K]] : never;
};

Which can then be called with Bazify<Bar, Foo> (or use type Baz = Bazify<Bar, Foo>; to keep existing-code-changes to a minimum)

It's worth noting that T[P] extends T[number] is used instead of simply P extends number because for some reason P acts like a pre 2.9 key and always extends string ("0" | "1" | "length" | ...) as opposed to string | number | symbol (0 | 1 | "length" | ...), which is probably a separate issue of its own.

[ahejlsberg]

The issue here is that we only map to tuple and array types when we instantiate a generic homomorphic mapped type for a tuple or array (see #26063). We should probably also do it for homomorphic mapped types with a keyof T where T is non-generic type.

[phiresky]

Just stumbled on what I assume is the same issue:

type n1 = [1, 2, 3]
type n2t<T> = {[k in keyof T]: 4}

type n2 = { [k in keyof n1]: 4 } // { length: 4, find: 4, toString: 4, ...}
type n2b = n2t<n1> // [4, 4, 4] as expected

I would expect n2 to behave like n2b.

[phiresky]

This also means that these constructs don't work:

type Test1<S extends number[]> = Record<number, "ok">[S[keyof S]];

type Test2<S extends [0, 1, 2]> = Record<number, "ok">[S[keyof S]];

The second one should definitely work. This means that it's impossible to map tuples to other tuples with a method that requires the value type of the input tuple to be known to extend something (e.g. number as above)

[ksaldana1]

Mathieu Lemoine (@lemoinem) You can get your current example to narrow correctly and avoid the behavior Wesley Wigham (@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.

[lemoinem]

Kevin Saldaña (@ksaldana1) Thanks, nice idea!
Actually my own WorkingBaz is a pretty good workaround as well, if I can say so myself:

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

It avoids the drawback of losing the Array prototype's methods (only their typing info, which are already much less useful on heterogeneous tuples...).
Although it's not recognized as [string, number], as far as I can tell, it's still an almost structurally equivalent type:
{ "0": string; "1": number; } & { length: 2; } & any[].

But I'd still expect this to work out of the box and produce the correct [string, number] type.

[WhiteAbeLincoln]

I'm also seeing the same bug. I was about to log an issue, but I saw this one in the related issues page.

For reference, the code I'm experiencing this bug with:
Search Terms:
tuple mapped type not assignable
Code

type Refinement<A, B extends A> = (a: A) => a is B
// we get the error `Bs[k] does not satisfy the constraint 'A'. Type A[][k] is not assignable to type A`
type OrBroken = <A, Bs extends A[]>(...preds: { [k in keyof Bs]: Refinement<A, Bs[k]> }) => Refinement<A, Bs[number]>
// same (well similar, [A, A, A][k] is not assignable vs A[][k] not assignable) error
type OrBroken1 = <A, Bs extends [A, A, A]>(...preds: { [k in keyof Bs]: Refinement<A, Bs[k]> }) => Refinement<A, Bs[number]>
// if we don't map over the type we don't receive the error
type OrWorks = <A, Bs extends A[]>(...preds: { [k in keyof Bs]: Refinement<A, Bs[0]> }) => Refinement<A, Bs[number]>
type OrWorks1 = <A, Bs extends A[]>(...preds: { [k in keyof Bs]: Refinement<A, Bs[number]> }) => Refinement<A, Bs[number]>

Expected behavior:
When mapping over a tuple type Bs where every element extends some type A, the mapped type Bs[k] should be assignable to A. In other words, OrBroken in the above example should not give an error
Actual behavior:
We recieve the error Bs[k] does not satisfy the constraint 'A'. Type A[][k] is not assignable to type A

Playground Link:
link

[augustobmoura]

You could just filter for number properties:

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

// Inverse of Exclude<>
type FilterOnly<T, N> = T extends N ? T : never;

type Baz = {
  [K in FilterOnly<keyof Foo, number>]: Bar[Foo[K]];
};

[lemoinem]

I think we have enough and various workarounds and comments from the TS team identifying the root issue.
If you have the same issue, may I suggest you add a thumbs up/+1 reaction to the initial comment (and subscribe to the issue so you will know when this is finally fixed) instead of commenting "Me too".

This will prevent spamming everyone in the thread. Thank you very much.
(I'm still eagerly waiting for a fix to this ;) )

[ccorcos]

Hey there, I'm running into this issue, except I'm using a generic tuple type instead of a statically declared tuple.

type PropertyType = "string" | "number" | "boolean"

type PropertyValueTypeMap = {
	string: string, 
	number: number, 
	boolean: boolean
}

type Args<A extends Array<PropertyType>> = {
	// ERROR: Type 'A[I]' cannot be used to index type 'PropertyValueTypeMap'.
	[I in keyof A]: PropertyValueTypeMap[A[I]] 
}

// RESULT: type A = [string, number]
type A = Args<["string", "number"]>

playground

Augusto Moura (@augustobmoura)'s FilterOnly approach doesn't work.
Kevin Saldaña (@ksaldana1)'s Exclude<keyof Foo, keyof any[]> approach also does not work.