Mapped Type `[Lhs of Rhs]` Syntax for Array and Tuple Types

Suggestion

🔍 Search Terms

mapped type, of, array, tuple

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

A new [Lhs of Rhs] syntax in mapped type to map over values of array and tuple types:

type ResultType = {
    [V of SourceType]: DoSomethingWith<V>
}

Rhs does not need to be a type parameter.
Rhs must extend readonly unknown[] or a type error is raised.

📃 Motivating Example

type Foo = ['hello', 'world']

type Bar = {
    [V of Foo]: V[]
}
// Bar = ['hello'[], 'world'[]]

💻 Use Cases

Currently, to do the same as in motivating example, one might intuitively write:

type Bar = {
    [K in keyof Foo]: Foo[K][]
}

However this is incorrect and is a mistake that's potentially difficult to spot.

Instead one must either introduce a generic intermediate type:

type Transform<T> = {
    [K in keyof T]: T[K][]
}

type Bar = Transform<Foo>

Or use the infer workaround:

type Bar = Foo extends infer T ? {
    [K in keyof T]: T[K][]
} : never

Both workarounds are not immediately obvious to inexperienced developers, less ergonomic, and will silently break when Foo is no longer an array or tuple type without putting extra constraints.

Inizia confrontando gli esempi proposti di [Lhs of Rhs] con il workaround esistente basato su keyof per i mapped types e il suo comportamento per array e tuple. Individua quindi le aree del compilatore e i test che regolano i mapped types, poi definisci la sintassi accettata, il vincolo readonly unknown[], i tipi tupla risultanti e le diagnostiche per i membri destri non validi.