Difference between async/await and ES6 yield with generators

yield can be considered to be the building block of await. yield takes the value it's given and passes it to the caller. The caller can then do whatever it wishes with that value (1). Later the caller may give a value back to the generator (via generator.next()) which becomes the result of the yield expression (2), or an error that will appear to be thrown by the yield expression (3).

async-await can be considered to use yield. At (1) the caller (i.e. the async-await driver - similar to the function you posted) will wrap the value in a promise using a similar algorithm to new Promise(r => r(value) (note, not Promise.resolve, but that's not a big deal). It then waits for the promise to resolve. If it fulfills, it passes the fulfilled value back at (2). If it rejects, it throws the rejection reason as an error at (3).

So the utility of async-await is this machinery that uses yield to unwrap the yielded value as a promise and pass its resolved value back, repeating until the function returns its final value.

Well, it turns out that there is a very close relationship between async/await and generators. And I believe async/await will always be built on generators. If you look at the way Babel transpiles async/await:

Babel takes this:

this.it('is a test', async function () {    const foo = await 3;    const bar = await new Promise(resolve => resolve('7'));    const baz = bar * foo;    console.log(baz);});

and turns it into this

function _asyncToGenerator(fn) {    return function () {        var gen = fn.apply(this, arguments);        return new Promise(function (resolve, reject) {            function step(key, arg) {                try {                    var info = gen[key](arg);                    var value = info.value;                } catch (error) {                    reject(error);                    return;                }                if (info.done) {                    resolve(value);                } else {                    return Promise.resolve(value).then(function (value) {                        return step("next", value);                    }, function (err) {                        return step("throw", err);                    });                }            }            return step("next");        });    };}this.it('is a test', _asyncToGenerator(function* () {   // << now it's a generator    const foo = yield 3;    //  <<< now it's yield, not await    const bar = yield new Promise(resolve => resolve(7));    const baz = bar * foo;    console.log(baz);}));

you do the math.

This makes it look like the async keyword is just that wrapper function, but if that's the case then await just gets turned into yield, there will probably be a bit more to the picture later on when they become native.

You can see more of an explanation for this here:https://www.promisejs.org/generators/

what the heck is the difference between the await keyword and the yield keyword?

The await keyword is only to be used in async functions, while the yield keyword is only to be used in generator function*s. And those are obviously different as well - the one returns promises, the other returns generators.

Does await always turn something into a promise, whereas yield makes no such guarantee?

Yes, await will call Promise.resolve on the awaited value.

yield just yields the value outside of the generator.