Suggestion

🔍 Search Terms

• mapped type
• type mapping
• generics
• generic function
• unknown

✅ 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

Performing type mapping on a generic type should result in a new generic type with that mapping applied, rather than a concrete type with unknown in place of generics.

📃 Motivating Example

Consider the following utility type Async<T>. It takes an arbitrary function signature and returns the signature of an equivalent asynchronous function.

type Async<T extends (...args: any) => any> = T extends (...args: infer Args) => infer Result
  ? (...args: Args) => Promise<Result>
  : never;

type SimpleFunction = (arg: number) => string;
type AsyncSimpleFunction = Async<SimpleFunction>;
// result: (arg: number) => Promise<string> ✅

Now let's give it a generic function:

type GenericFunction1 = <T>(arg: T) => string;
type AsyncGenericFunction1 = Async<GenericFunction1>;
// expected: <T>(arg: T) => Promise<string>
// actual: (arg: unknown) => Promise<string> ⛔️

type GenericFunction2 = <T>(arg: number) => T;
type AsyncGenericFunction2 = Async<GenericFunction2>;
// expected: <T>(arg: number) => Promise<T>
// actual: (arg: number) => Promise<unknown> ⛔️

As this example shows, we cannot use the helper type Async<T> with a generic function signature. If we try, we get a non-generic function signature with unknown wherever a generic argument was used.

💻 Use Cases

We maintain a plugin system. Plugins are developed against a carefully designed API. For every type in the plugin API, there is a corresponding internal type. Plugin values and internal values are identical at runtime, but their types differ. For instance, the same concept may be represented by a class internally, but by a branded interface towards the plugins.

To convert between an internal type and its corresponding plugin type, we use a recursive mapped type. This words great, unless the value is (or contains) a generic function.