Feature request: typed yield expression

Search Terms

generator, iterator, yield, type inference, co, redux-saga

Related Issues

#32523

Suggestion

Allow passing of yield operator signature to generator functions

declare function fetchUser(): Promise<User>;
function asyncAction*(yield: <R>(p: Promise<R>) => R) {
  const user = yield fetchUser(); // user type inferred to User based on yield param
  // impl
}

where yield inside params list is a pseudo-parameter similar to this.

Use Cases

Discussion of use cases is given in #32523.

My intended use is case is emulating do notation for monads with generator functions.
This implies I would normally have some generator runner that does composition defined before writing generator function, so type of expression at which generator resumes is trivially inferrable based on yielded value.

Discussion

The hard thing in typing yield expressions in is that resumed type does not depend only on passed parameters and generator type, but also on context in which the generator is run.

There is a precedent in TypeScript with similar situation -- this parameter in functions.
The situation is analogous -- what this behaves like depends on which object function is member of.

The proposal is to allow declaring contextual info about yield inside generator functions, by introducing appropriate pseudo-param.

I could see this working in two ways:

• yield param gets erased early, it does not affect generator function signature,
  it serves merely as a contract for type-checking / inferrence inside body

function asyncAction*(yield: <R>(p: Promise<R>) => R) {
  // impl
}
typeof asyncAction == () => Generator<...>

• yield param is preserved as type info like this param.
  then it is always present on types of shape (yield: ...) => Generator<> and defaults to (a: any) => any.

function asyncAction*(yield: <R>(p: Promise<R>) => R) {
  // impl
}
typeof asyncAction == (yield: <R>(p: Promise<R>) => R) => Generator<...>

Additionaly

1. signature of yield must extend (a: any) => any and defaults to it

function asyncAction*(yield: number) {
  // impl
}
// Error: signature must be of shape (any => any)

2. yielded values inside generator function body must be assignable to argument of yield signature

function asyncAction*(yield: (s: string) => void) {
  yield 7; // Error: number is not assignable to string
}

3. this parameter has no effect on Generator<> return type, whether declared or
   other than obvious coherence guaranteed by (2)

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
  thats an opt-in feature
• This wouldn't change the runtime behavior of existing JavaScript code
  type level feature, doesn't affect runtime behavior
• 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.

Start by reading related issue #32523 and the proposal's generator, iterator, and yield examples. Compare the two proposed treatments of the pseudo-parameter and its typing rules; done requires an agreed design that covers yielded values, resumed types, function signatures, and existing Generator behavior.