createAsyncFunction.js

function createAsyncFunction(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) {
            step("next", value);
          }, function (err) {
            step("throw", err);
          });
        }
      }
      return step("next");
    });
  };
}

Hello Jake!

I don't even know how I got to this function (I've got dozens of tabs open while I research asynchronous javascript). At first I found it quite cryptic, but I took figuring it out as a challenge.

So after a few days tinkering with it I believe It takes a generator function, then returns a function that accepts arguments that might be used by such generator function to craft an Iterable. Then it creates said iterable (as a generator object), then returns a pending promise that will start an iteration sequence and only settle when an iteration throws an error, returns a rejected promise, or is the last one.

Now here's the motivation for this comment: I believe the return statements on lines 23 and 16 are both unnecessary/inert. The reasoning being:

For line 23:

• the returned value of a Promise constructor's executor function is always ignored;
• the only purpose of such a return statement in an executor function is flow control (preventing subsequent code from executing), as you do on line 11.

For line 16:

• it's flattening a chain of promises (that started with the first call to step on line 23). Each of the promises entering a handler function with a call to step in the microtask queue. There's no point in chaining those promises, is there? Since in the end the resulting promise will be returned in line 23 (and ignored).

TL;DR: For didactic purposes I removed the return statements in lines 16 & 23, kept the returned expressions. Code worked the same.

I don't even think you'll be bothered with this, but still serves me as an exercise, though.

Loved your event loop talk in JSConf.Asia!

Cheers

So it's a polyfill from Babel, nevermind then.

Yep!