Allow generic yield* types

[Validark]

Search Terms

generic yield asterisk type preserve

Suggestion

Currently, the yield* construct doesn't work properly with generic types. I would like to see these kinds of situations get proper types:

function* foo<T extends Iterable<any>>(x: T) {
    yield* x;
}
// Inferred return type: `Generator<any, void, undefined>`

I would like to see some kind of Iteratorify types added:

type YieldTypeOfIterableType<R> = R extends Iterable<infer Y> | Iterator<infer Y> | IterableIterator<infer Y> | Generator<infer Y> ? Y : never;

type Awaited<T> =
  T extends null | undefined ? T : // for non-strictNullChecks
  T extends PromiseLike<infer U> ? Awaited<U> :
  T;

/** Extracts the `Symbol.asyncIterator` return type, falling back to the `Symbol.iterator` return type if necessary. */
type AsyncIteratorify<T> = [T] extends [{ [Symbol.asyncIterator]: () => void } | { [Symbol.iterator]: () => void }]
    // Tests whether a given type has a valid AsyncIterator / Iterator in every unioned type before actually computing the type
    // This is so AsyncIteratorify<Set<string> | {}> will resolve to `never`
    ? T extends infer U
        ? U extends { [Symbol.asyncIterator]: () => infer R }
            ? YieldTypeOfIterableType<R>
            : U extends { [Symbol.iterator]: () => infer R }
                ? Awaited<YieldTypeOfIterableType<R>>
                : never
        : never
    : never;

/** Extracts the `Symbol.iterator` return type. */
type Iteratorify<T> = [T] extends [{ [Symbol.iterator]: () => void }]
    // Tests whether a given type has a valid Iterator in every unioned type before actually computing the type
    // This is so Iteratorify<Set<string> | {}> will resolve to `never`
    ? T extends infer U
        ? U extends { [Symbol.iterator]: () => infer R }
            ? YieldTypeOfIterableType<R>
            : never
        : never
	: never;

function foo<T extends Iterable<any>>(arr: T): Generator<Iteratorify<T>>;
function* foo<T extends Iterable<any>>(x: T) {
    yield* x;
}

for (const x of foo([1, 2])) console.log(x); // x is a number :D

However, this still won't work for generic this parameters in Symbol.iterator calls:

for (const x of foo({
    a: 1,
    *[Symbol.iterator]<T>(this: T) {
        for (const x in this) yield x;
    }
})) console.log(x);

For this, we would need #37181 (and we would need a way to allow for passing in implicit this parameters in that proposal)

Checklist

My suggestion meets these guidelines:

• 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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[rbuckton]

This is marked as a bug, but it's not clear to me what is being asked for here. The current type is consistent with what you would get if you did for..of, in that we don't try to construct a type that extracts the yielded type of T and instead give you the yielded type from the constraint:

Playground

Are you asking that we introduce some type of IteratorNext<T>/IteratorReturn<T> types like we have with Awaited<T>? If so, I would classify this as more of a feature request than a bug.