将功能*提升为异步功能*？

Question

假设我有一个函数，它接受一个生成器并返回第一个n元素的另一个生成器：

const take = function * (n, xs) {
  console.assert(n >= 0);
  let i = 0;
  for (const x of xs) {
    if (i == n) {
      break;
    }
    yield x;
    i++;
  }
};

用法如下：

const evens = function * () {
  let i = 0;
  while (true) {
    yield i;
    i += 2;
  }
};

for (const x of take(10, evens())) {
  console.log(x);
}

现在想象evens也是async（请参阅this answer进行设置）：

const evensAsync = async function * () {
  let i = 0;
  while (true) {
    yield i;
    i += 2;
  }
};

当然，这与take不兼容：

const main = async () => {
  for await (const x of take(10, evensAsync())) {
    console.log(x);
  }
};

main().catch(e => console.error(e));

现在，我可以定义take变种async：

const takeAsync = async function * (n, xs) {
  console.assert(n >= 0);
  let i = 0;
  for await (const x of xs) {
    if (i == n) {
      break;
    }
    yield x;
    i++;
  }
};

const main = async () => {
  for await (const x of takeAsync(10, evensAsync())) {
    console.log(x);
  }
};

main().catch(e => console.error(e));

......但是麻烦啊！

有没有办法在JavaScript中自动“异步”生成器函数？

Answer 1

有没有办法在JavaScript中自动“异步”生成器函数？

不，异步和同步发电机太不一样了。你将需要两个不同的take函数实现，没有办法解决它。

但是，您可以动态选择要选择的项目：

async function* takeAsync(asyncIterable) { … }
function* takeSync(iterable) { … }

function take(obj) {
    if (typeof obj[Symbol.asyncIterator] == "function") return takeAsync(obj);
    if (typeof obj[Symbol.iterator] == "function") return takeSync(obj);
    throw new TypeError("not an iterable object");
}

编写一个可以像asyncify一样使用的函数asyncify(takeSync)(10, evensAsync())通常不可能。人们可能能够共同破解适用于takeSync和mapSync的东西，依赖于每个输入项目只输出一个项目的事实，但它会非常脆弱，不适用于其他迭代函数，如filter。

也就是说，当然可以概括和提供抽象。

function taker(n) {
  return {
    done: n > 0,
    *step(element) { /* if (n > 0) */ yield element; return taker(n-1); },
    result: null
  }
}
function mapper(fn) {
  return {
    done: false,
    *step(element) { yield fn(element); return this; }
    result: null
  }
}

function makeIterator(t) {
  return function*(iterable) {
    for (let element of iterable) {
      t = yield* t.step(element);
      if (t.done) break;
    }
    return t.result;
  };
}
function makeAsyncIterator(t) {
  return async function*(asyncIterable) {
    for await (let element of asyncIterable) {
      t = yield* t.step(element);
      if (t.done) break;
    }
    return t.result;
  };
}

（无耻地撕掉了transducer concept - 也没有测试任何东西）