6

I just took a look at Dave Herman's very interesting task.js. In his example he has this line:

var [foo, bar] = yield join(read("foo.json"),
                                read("bar.json")).timeout(1000);

I'm familiar with generators but I don't understand how the yield expression evaluates to something that can be assigned to [foo, bar]. I actually wouldn't have expected the expression to be assignable to anything since it is basically the same thing as return.

The yield syntax for JS still seems a bit underdocumented and I couldn't find info about this.

So to clarify my question: what ends up being assigned to foo and bar?

Dheeraj Vepakomma
  • 26,870
  • 17
  • 81
  • 104
Matthew Gertner
  • 4,487
  • 2
  • 32
  • 54

2 Answers2

6

Actually, the relevant paragraph is a little below in https://developer.mozilla.org/En/New_in_JavaScript_1.7:

Once a generator has been started by calling its next() method, you can use send(), passing a specific value that will be treated as the result of the last yield. The generator will then return the operand of the subsequent yield.

I think that this is only relevant if the generator is used by calling its methods directly, not when looping over its values - a loop will always call next() on the generator and never send().

In a way, generator execution is similar to cooperative multitasking. The generator executes until the yield statement is found. It returns control to whoever called next() or send() on the generator. The caller then continues executing, until the next next() or send() call is performed - now the generator is executing again. Each time values can be passed back and forth.

Here a simple example:

function gen()
{
  var [foo, bar] = yield 1;
  console.log("Generator got: " + foo + ", " + bar);
}

// This creates a generator but doesn't run it yet
var g = gen();

// Starts generator execution until a yield statement returns a value
var result = g.next()
console.log("Received from generator: " + result);

// Continue generator execution with [2, 3] being the return value
// of the yield statement. This will throw StopIteration because the
// iterator doesn't have any more yield statements.
g.send([2, 3]);
Wladimir Palant
  • 56,865
  • 12
  • 98
  • 126
0

https://developer.mozilla.org/En/New_in_JavaScript_1.7

The function containing the yield keyword is a generator. When you call it, its formal parameters are bound to actual arguments, but its body isn't actually evaluated. Instead, a generator-iterator is returned. Each call to the generator-iterator's next() method performs another pass through the iterative algorithm. Each step's value is the value specified by the yield keyword. Think of yield as the generator-iterator version of return, indicating the boundary between each iteration of the algorithm. Each time you call next(), the generator code resumes from the statement following the yield.

joar
  • 15,077
  • 1
  • 29
  • 54
  • 3
    I understand all that by I don't understand why the yield statement doesn't occur in a loop (which I would expect to get iterator-style semantics) and why there is a direct assignment performed using whatever the yield evaluates to. As you say, it's like a return, so this seems to me like saying `var something = return something_else;`. I've never seen that usage and I'm not sure what it would mean. – Matthew Gertner Aug 12 '11 at 07:28