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.

Bắt đầu bằng cách so sánh các ví dụ [Lhs of Rhs] được đề xuất với workaround hiện có dựa trên keyof cho mapped types và hành vi của nó đối với array và tuple. Sau đó, xác định các khu vực của compiler và các test chi phối mapped types, rồi định nghĩa cú pháp được chấp nhận, ràng buộc readonly unknown[], các kiểu tuple kết quả và các chẩn đoán cho các vế phải không hợp lệ.