Can you help me, why it works?

Sure. Let me break down what is happening here.

The whole syntax being used here is key remapping - also used in other solutions. It allows us to change or filter out keysets.

In the remap logic, we are determining which keys need to be filtered out via conditional typing:

as Key extends `${infer ConcreteKey}` ? ConcreteKey : never

We can phrase the logic here like "If the key being remapped is a string literal (or a specific string value instead of the generic string), retain the key (by returning the original key), otherwise, filter it out (by returning never, see documentation).

As for the condition:

Key extends `${infer ConcreteKey}`

We are trying to infer if the key can be pulled out of a template literal. From definition, template literals are built on string literal types, which would be the only types you can infer from it and not a generic string. Also, string can only extend the types string and any AFAIK, thus the condition resulting in false and filtering out generic types.

As to how TS handles these internally, I am not sure about those, the docs I have linked may be able to give insights about it. Hope these help.

awesome! thanks a lot!

Wow, the best explanation I've ever seen! Thanks!

great explanation and thanks for the doc links!

Hi @ianbunag could you please also explain why Key in keyof Type
as Key extends has been used i really don't understand at index level why there is a requirement for as Key syntax, as we are already getting value for that using in keyof syntax.
the other question is sometime i have also seen that at argument level like
```
type RemoveIndexSignature<T, K extends keyof T> = {
[P in keyof T]: T[P]
}

could you also explain we are using keyof in 2 places in above example
      

Hey, my answer is outdated, I would recommend checking this answer as it passes all the latest test cases (even symbols which my answer previously supported).

why there is a requirement for as Key syntax, as we are already getting value for that using in keyof syntax

as Key is used to modify the type returned by keyof syntax. In my case I only wanted to get the keys that are string literals, anything generic will be filtered out.

Here is an example:

type DoNothing<Type extends Record<string, unknown>> = {
  [Key in keyof Type]: Type[Key]
}

type Base = {
  hello: string,
  hi: number,
}

/**
 * type AllFields = {
 *   hello: string,
 *   hi: number,
 * }
 */
type AllFields = DoNothing<Base>

type PickNumberFields<Type extends Record<string, unknown>> = {
  // Iterate over all keys (Key) of the parameter (Type)
  // Then check if the value associated with the current Key in Type is a number
  // If it is a number, retain, otherwise filter it out by remapping to never
  [Key in keyof Type as Type[Key] extends number ? Key : never]: Type[Key]
}

/**
 * type NumberFields = {
 *  hi: number;
 * }
 */
type NumberFields = PickNumberFields<Base>

Play with this in TypeScript playground.

See this comment for a thorough explanation.