No it wouldn't. yields must be lexically in a generator function. They cannot suspend across stack frames.

That means it's nothing that a Scala macro couldn't do with local transformations. There is no need to have dedicated language support for that.

If generators had brought a unique superpower like coroutining, we would have added support for them years ago, already in the 0.6.x era.

Related: #5064
That does actually bring such a superpower. But it's only going to work on Wasm.

@sjrd do you have any feel for whether generator chaining is optimized by VMs? (e.g. await-ing a promise created by a generator func might be much more efficient than an arbitrary promise).

Generators and await are two different things. Generators are not Promises. Well they're orthogonal: you can write an async generator, but that composes the notion of a generator with that an async function.

Anyway, good question. For async/await, I would be surprised if they are optimized in any specific way, because by spec each await must happen in a separate microtask of the job queue. For generators and yield, it's possible that they do something clever. I haven't seen anything about it, but I haven't been looking either.

Thanks for the reply :)

yields must be lexically in a generator function. They cannot suspend across stack frames.

Yes, that is correct. So while it is not possible to implement stackful coroutines, it is possible to implement stackless coroutines using yield.

That means it's nothing that a Scala macro couldn't do with local transformations. There is no need to have dedicated language support for that.

I didn't realize that this is something that could be implemented with a macro instead of a compiler plugin.

In any case, I also wondered if there would be a performance advantage to preferring yield.

Here is a recent document about the implementation of generators in V8.

https://docs.google.com/document/d/1-iFoVuvpIEjA9dtSsOjmKL5vAzzvf0cKI6f4zaObiV8/

Edit with my thoughts:

• Maglev and Turboshaft refer to V8's optimizing compilers. The fact that support for yield exists at multiple compiler levels (and not simply an early AST-level rewrite) suggests to me that they are applying optimizations that would not be possible to achieve with local transformations of Scala code.

• Additionally, it seems like await may also be implemented in terms of generators. So there may be a performance advantage here as well over the equivalent Scala plugins.

Proof of concept: #5082.

Feel free to try it out. If you can get some benchmarks with measurable improvements, that would give a good case to push this further.