Repository: TypeScript
Issue: Type subscope for local type aliases
Labels: Suggestion,Awaiting More Feedback

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker.

Please help us by doing the following steps before logging an issue:
  * Search: https://github.com/Microsoft/TypeScript/search?type=Issues
  * Read the FAQ, especially the "Common Feature Requests" section: https://github.com/Microsoft/TypeScript/wiki/FAQ

-->

## 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

```ts
// 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:

```ts
// 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:

```ts
// 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:

```ts
// 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:

```ts
// 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:

* [X] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [X] This wouldn't change the runtime behavior of existing JavaScript code
* [X] This could be implemented without emitting different JS based on the types of the expressions
* [X] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [X] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).