Feature request: typed yield expression

[rerion]

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.

[tadhgmister]

To clarify intent: Currently without an explicit return type annotation all yield expressions give type any and no check is done on the yielded value. (Both of these behaviours are completely correct.) This suggestion is to have a way to specify that yield(v) should be type checked as if yield has a known function signature. No other current behaviour would be affected at all by this suggestion.

For context, a lot of the discussion on #30790 is requesting a feature like this. The conversation is well summed up as this:

1. How do we write code for libraries like co or redux-saga?
2. you would need a way to relate the yielded type to the next type, which we currently don't support
3. writing the relationship for a library is easy, shame I can't tell it to typescript.
4. Maybe we'd need higher order generics?

Higher order generics kind of went out the window being replaced with the much more useful Type inference in conditional types #21496. This suggestion composes well with all already existing constructs, it's just a way to let yield(v) be type checked like it was any other function.

[tomwidmer]

Does this extend to multiple relationships between yielded types and the type of the yield expression? Can you do:

interface CallExpression<Args extends any[], R> {
  type: "__call__;
  f: (...args: Args) => R;
  args: Args;
}

function call<Args extends any[], R>(f: (...args: Args) => R, ...args: Args): CallExpression<Args, R> {
  return {type: "__call__", f, args};
}

type YieldMapping = {
  // as many overloads as you like:
  <R>(p: Promise<R>) => R;
  <Args extends any[], R>(call: CallExpression<Args, R>) => R;
};

function f(a: number) { return a + 1 };

function *mygenerator(yield: YieldMapping): number {
  const n = yield Promise.resolve(10); // n inferred as type number
  return yield call(f, n); // return inferred as type number, since R is inferred from CallExpression
}

You'd need something like that to make redux saga type-check. I think this proposal seems potentially workable. I'm currently steering away from generators in TS purely because of the lack of yield type-checking, but they are much more powerful than async/await.

[mikecann]

For others that might have landed on this issue trying to find a solution. MobX State Tree uses generator functions for its async actions structure. I have written a library that helps with the typing by turning the flow into a continuation style syntax.

https://github.com/mikecann/mst-flow-pipe#readme

It means that each step (yeild) in the function is type safe once more. Not a perfect solution but it works for now.

[tadhgmister]

For people who are using something like redux-saga and looking for a work around, I want to make my work around here easier to find (particularly for myself 😄