Support conditional types for Generator T / TNext / TReturn

[JAForbes]

🔍 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>
})

[fatcerberus]

This sounds like a variant of #33912 just with generators instead of functions.

[nmain]

See #43632 as well

[JAForbes]

This sounds like a variant of #33912 just with generators instead of functions.

Just for clarification. I don't think it is . Isn't #33912 about inferring the return type by analyzing the control flow of a function. That's now what I am suggesting.

I want to explicitly define the behavior of a given generator function with a predefined conditional type.

That way a framework can say "if you yield x, we will inject y". There is no need to analyze control flow of the function it is part of a framework's presented API.

Also I think this allows typescript to fix its lack of typing for yielded values in generators without introducing a breaking change for old code, and without requiring any new config option in tsconfig, because defining a conditional type is completely opt in.

Finally, I think this should already work based on how conditional types operate in every other context, its arguably a bug and at least surprising behavior that it doesn't.

I think #43632 is solving the same problem in a different way. But I think @Andarist had the same idea in the comment thread of that issue:

However, this is a valid criticism and maybe an alternative approach could be figured out. For instance, we could "dispatch" to the injected type using conditional types like this:
comment

I think the suggestion in #43632 is to define a YieldType in scope of the generator and then yielded values that adhere to that type will magically be inferred to be the Yield type.

My approach is that conditional types as implemented just also support yielded values. You would need to explicitly annotate the generator to use a specific instance of Generator<X,Y,Z> where X,Y,Z can all be conditional types. It wouldn't magically inject into generators in scope.