Difference between Yield and Yield* operators in Ecmascript 6.0 "Harmony"?

Question

I’m studying the use of generators in Ecmascript 6.0 "Harmony".

I have already managed to understand its basic functioning, like the statement through the syntax function* () { ... } and value production through the operator yield.

However, I still cannot find a satisfactory explanation for the operation of the operator yield*. In the page on generators of the official language wiki the following code, which would be equivalent to that operator, in terms of the operator yield:

let (g = <<expr>>) {
    let received = void 0, send = true, result = void 0;
    try {
        while (true) {
            let next = send ? g.send(received) : g.throw(received);
            try {
                received = yield next;
                send = true;
            } catch (e) {
                received = e;
                send = false;
            }
        }
    } catch (e) {
        if (!isStopIteration(e))
            throw e;
        result = e.value;
    } finally {
        try { g.close(); } catch (ignored) { }
    }
    result
}

Still I could not clearly understand the purpose or effect obtained with the use of this operator. Someone could explain to me?

Answer 1

I’m still crawling on ES6, but from what I understand yield* is necessary when you want to delegate the yield to another Gen. I found a simple example:

let delegatedIterator = (function* () {
  yield 'Hello!';
  yield 'Bye!';
}());

let delegatingIterator = (function* () {
  yield 'Greetings!';
  yield* delegatedIterator;
  yield 'Ok, bye.';
}());

// Prints "Greetings!", "Hello!", "Bye!", "Ok, bye."
for(let value of delegatingIterator) {
  console.log(value);
}

Notice that yield* delegatedIterator; consumes completely the delegatedIterator. If you used yield delegatedIterator.next(), the exit would be "Greetings!", "Hello!", "Ok, bye.".

Well, that’s how I understood it, but as I said I’m not quite sure on ES6 yet. And I couldn’t find a tool to test this...