code: function _make(g) {
  
    function f(...args) {
  
      // Resolve the promise which will trigger recomputation.
      function run()         { runner(); }
      function accessStart() { accessController.start(); }
      function accessStop()  { accessController.stop(); }
  
      function iterate() {
        var change = new Promise(resolve => runner = resolve);
        function reiterate() { change.then(iterate); }
  
        accessStart();
        var {done, value} = iterator.next(args);
        console.assert(!done, "Iterator underlying computable ran out of gas.");
  
        var promise = Promise.resolve(value);
        promise.then(accessStop, accessStop); // should this be synchronous?
        promise
          .then(
            newValue => result = result.change(newValue),
            reason => { console.log(reason); }
          )
          .then(reiterate);
      }
  
      var iterator = g(run);
      var result = makeUpwardable(iterator.next().value);
      var accessController = makeAccessController(run);
      var runner;
  
  //    if (computed) {
  //      accessNotifier.notify({type: 'update',  object: computed});
  //    }
  
      observeArgs(args, run);
      iterate();
      return result;
    }
  
    return f;
  }
docs: Create an upwardable function based on a generator. The generator must provide the following behavior. The first `iterator.next()` is invoked synchronously, and must yield a neutral, default, safe value. Following `iterator.next()` calls are passed function arguments as an array. In other words, `yield` statements should be written as `args = yield x;`, where `args` will be/should be/might be used in deriving the next value to yield. The yielded value may be (but not need be) be a promise to be waited for.