Type subscope for local type aliases

Search Terms

type scope, type iife

Suggestion

A syntax that allows for a type subscope (like a js IIFE).

Use Cases

When constructing complex types, they are often not very readable without breaking them up into multiple type aliases. However, this means that you have to pass the type aliases through, along with their constraints, and it can become even less readable.

Examples

Basic examples of the concept / suggested syntax

// All of the below are equivalent to { p: { q: T } }

type X0<T> = {{
  type A = { q: T };
  type B = { p: A };
  type = B;
}}; 

type X1<T> = {{
  type = B;
  type A = { q: T };
  type B = { p: A };
}}; 

type X2<T> = {{
  type Q<U> = { q: U };
  type A = Q<T>;
  type B = { p: A };
  type = B;
}}; 

type X3<T> = {
  p: {{
    type A = { q: T };
    type = A;
  }};
};

type X4<T> = {{
  type = { p: { q: T } };
}};

Example of applying this to a real-world type

Consider the traditional approach in the following type:

// Bluebird-esque promisifyAll (monolithic):

type PromisifyAll<T> = {
  [K in keyof T & string as `${T}Async`]: (
    T[K] extends (...args: infer A) => void
      ? A extends [...infer B, (error: any, result?: infer R) => void]
        ? (...args: B) => Promise<R>
        : never
      : never
  )
}

This isn't very readable; it might help to extract some of it to type aliases:

// Bluebird-esque promisifyAll (refactored to type aliases):

type OrigArgs<Value> = Value extends (...args: infer A) => void ? A : never;
type SplitArgs<OrigArgs extends any[]> =
  OrigArgs extends [...infer A, (error: any, result?: infer R) => void]
    ? { args: A, result: R }
    : never;
type Func<SplitArgs extends { args: any[], result: any }> = (...args: SplitArgs["args"]) => Promise<SplitArgs["result"]>;
type PromisifyAll<T> = {
  [K in keyof T & string as `${T}Async`]: Func<SplitArgs<OrigArgs<T[K]>>>
}

That doesn't look great, pollutes the type scope, and has a bit of extends boilerplate.

With this proposal, you could write:

// Bluebird-esque promisifyAll (refactored to use type subscope):

type PromisifyAll<T> = {
  [K in keyof T & string as `${T}Async`]: {{
    type Value = T[K];
    type OrigArgs = Value extends (...args: infer A) => void ? A : never;
    type SplitArgs =
      OrigArgs extends [...infer A, (error: any, result?: infer R) => void]
        ? { args: A, result: R }
        : never;
    type Func = (...args: SplitArgs["args"]) => Promise<SplitArgs["result"]>;
    type = Func;
  }}
}

Or, a terser variant:

// Bluebird-esque promisifyAll (refactored to use type subscope, terser):

type PromisifyAll<T> = {
  [K in keyof T & string as `${T}Async`]: {{
    type OrigArgs = T[K] extends (...args: infer A) => void ? A : never;
    type SplitArgs =
      OrigArgs extends [...infer A, (error: any, result?: infer R) => void]
        ? { args: A, result: R }
        : never;
    type = (...args: SplitArgs["args"]) => Promise<SplitArgs["result"]>;
  }}
}

While we're all used to nested conditional types, if you saw the equivalent of the original type definition in runtime code, you would likely agree that it should be refactored.

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.

No implementation files or tests are named. Start by reviewing the proposed type-subscope syntax and examples, then trace the compiler areas responsible for parsing and resolving type aliases; done requires an agreed syntax and corresponding type-system behavior with tests.