When using spread syntax on a generator why return value is not retrieved

Question

I was expecting 4 to be part of the sequence array, so why is it skipped?

function* generate() {
 yield 1;
 yield 2;
 yield 3;
 return 4
}
let sequence = [...generate()];
console.log(sequence); // 1, 2, 3

• Gabriele Petrioli: @MisterJojo there is, but it finishes the generator.
• Mehdi Benmoha: @MisterJojo the return statement is marking the generator end with the attribute done:true
• Gabriele Petrioli: yes all of the iterators do not use the done:true. for (x of genarator()) will also not get it.
• Pointy: The done flag is checked in a way that ignores the value returned. When done is true, iteration is complete.
• Gabriele Petrioli: Read developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/… "Done: This is true if the last value in the sequence has already been consumed."

Answer 1

The return value of a generator function is not considered part of the sequence. It is returned from the last .next() call as {done: true, value:...}, where done: true implies that the sequence was completed and .next() should not be called again.

Why is that so, why couldn't we just yield the last value with the done flag set to true? Because then we could not represent an empty sequence with an iterator - the first .next() call would already lead to at least one value.¹

So usually, generator functions do not return anything (but undefined), and all sequence values are yielded with the same syntax - there is no weird special syntax for the last value²:

function* generate() {
 yield 1;
 yield 2;
 yield 3;
 yield 4;
}

_{1: Other languages do this differently. There, iterators have a separate .hasNext() method that is called before .next(), or their .next() method either returns a value or throws a StopIteration exception. They don't have any "final value".
2: Having to know beforehand that a value is that last and using return instead of yield for it would make the logic for dynamically generated sequences much more complicated.}

• user5536315: This happens if you combine a function that must return a value with an ambiguous computation (e.g. []). You are stuck with a meaningless return value. The iterator protocol has no formal foundation. It is poorly designed and ignores decades of CS.
• Patrick Roberts: Best part of the answer is explaining why this approach allows us to represent an empty sequence, as opposed to the alternative that the question implies. Also in response to your footnote, you can think of next() as a sort of std::optional where done is !has_value.
• Bergi: @scriptum I understand the IteratorResult type to be a poor man's Maybe for the usual iterator use case - you either have {done: false, value: ...} or {done: true}. Also, generator functions additionally serve as coroutines in JS, and for them the final value is rather useful.