[Bug]stricter Generators: `T` not in scope

[kgtkr]

TypeScript Version: 3.6.0-dev.20190720

Search Terms:
Generators

Code

function* foo(): {
  next<T>(x: T): IteratorResult<void, void>;
} {
  // x: T
  const x = yield;
}

Expected behavior:
It is necessary to discuss how it should work

Actual behavior:
x: T

Related Issues:
#30790 #31639

[kgtkr]

other example

code

function* foo(): {
  next<T>(x: T): IteratorResult<T, void>;
} {
  // x: T
  const x = yield 1;
}

Expected behavior

x: number

Actual behavior

x: T

main.ts:5:19 - error TS2322: Type '1' is not assignable to type 'T'.
  '1' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{}'.

5   const x = yield 1;
                    ~


Found 1 error.

[falsandtru]

This is #30790 (comment) and #32523.

[rbuckton]

Your second example looks like it should be an error. If your generator return type says the definition for next is <T>(x: T) => IteratorResult<T, void>, then you should only be yielding the thing that was sent with next, however that's not how generators work.

[rbuckton]

As odd as it looks, I'm not even certain that the first example is really an error. We contextually type the result of yield as the type of the argument that is passed to next. The only other thing we could do here is possibly make the result unknown or any, but T is actually better here (especially if T had a constraint):

function * foo(): {
  next<T extends string>(value: T): IteratorResult<unknown, void>;
} { 
  // x is 'T extends string'
  const x = yield;
  x.charAt(0); // ok
}

@DanielRosenwasser, @RyanCavanaugh this seems like something that might warrant further discussion?

[falsandtru]

Anyway parametric iterator methods are useless without supporting Rank-2 types.

function* foo(): {
  next<T>(x: T): IteratorResult<T, void>;
} {
  // T is `undefined | number`.
  yield undefined; // Return type is `undefined | number`, not `undefined`.
  yield 1; // Return type is `undefined | number`, not `number`.
}

https://prime.haskell.org/wiki/Rank2Types

Overloading may help us but it also brings some inconveniences.

function* foo(): {
  next<T extends undefined>(x: T): IteratorResult<T, void>;
  next<T extends number>(x: T): IteratorResult<T, void>;
} {
  yield undefined; // Return type is `undefined`.
  yield 1; // Return type is `number`.
}