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));

... 但是麻烦！

有没有办法自动＆＃34; asyncify＆＃34; JavaScript中的生成器函数？

Answer 1

有没有办法自动＆＃34; asyncify＆＃34; 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 - 也没有测试任何东西）

将功能提升为异步功能？

1 个答案:

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

1 个答案:

将功能提升为异步功能？