Support conditional types for Generator T / TNext / TReturn

🔍 Search Terms

"Generator", "Async Generator", "conditional types", "const" "inference"

✅ Viability Checklist

• 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 isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

If a generator function is specifically typed to have a conditional relationship between T and TNext then type inference should allow for a type narrowed result according to that conditional type.

📃 Motivating Example

Typescript would be able to support complex type state management (ala redux saga), coroutines (e.g. co) and the interpreter pattern / free monad/applicative.

In the past this was not possible, but given typescript now has as const, infer and conditional types, we should be able to support typed yield result inference in key circumstances.

Something like this would be possible:

type Yielded<T> 
  T extends Promise<infer U>
   ? U // awaited
   : T  // return the original yielded value
   
function co<T>( fn: () => Generator<T, T, Yielded<T>> ) : Promise<T> {...}

💻 Use Cases

1. What do you want to use this for?

Complex state management and side effects.

2. What shortcomings exist with current approaches?

For generator functions yielded values are always typed as any. For async generators yielded values are a union of all possible results.

3. What workarounds are you using in the meantime?

Manually casting

doSomething(function * f(){
    let value = (yield someStream) as UnwrapStream<typeof someStream>
    let another = (yield somePromise) as UnwrapPromise<typeof somePromise>
})

Start with the motivating generator example and compare the requested conditional relationship between T, TNext, and TReturn with the stated current behavior for generators and async generators. Done means conditional inference supports the described typed yield results without changing emitted JavaScript, with coverage for the motivating cases.