[Feature] Utility type for T[keyof T] or new keyword valueof

Search Terms

typeof keyof utlity type

Suggestion

Alternative 1:
Create a new Utility type expressing T[keyof T]
Example Value<T> = T[keyof T].

Alternative 2:
Create a new keyword equivalent to T[keyof T]
Example valueof T = T[keyof T]

Use Cases

While T[keyof T] is short and concise, from my experience a lot of developers new to TypeScript usually have no idea what this means or why it's written like that when they first see it.
I also feel that it's not as easy to Google a the answer to that, in comparison to established utility and advanced types like Pick, Omit, Record, etc. which all have their own entries in the TS documentation.

Additionally Object.keys and Object.values are similar concepts.
The presence of a keyof keyword would suggest a valueof should also exist, yet it's missing and one must employ a "special" approach to replicate.

A simple solution is to write my own custom type for the project, but that just introduces additional abstraction and the knowledge/practice isn't transferable to other projects, without implementing the same custom type somewhere in the code first.

And lastly, and this is not a big issue, but I feel it's redundant having to write the type for T twice in on the same line just a few symbols apart.
With short names such as T it's okay, but with longer type names the code becomes more cumbersome to read.

Examples

type T = {
    a: string;
    b: number
    c: number[]
    ...etc
}

// Value<T> = string | number | number[]...
// valueof T = string | number | number[]...

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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.
  Perhaps some conflict on point 8...

No files, tests, or entry points are named. Start by reviewing the proposed Value<T> utility type and valueof T keyword alternatives, then determine the language-design and compiler scope needed to choose between them. Done means a settled design and an implementation plan, but the issue does not define acceptance tests.