Support for iterables?

[rauschma]

What would support for sync and async iterables look like?

[sxzz]

The return value of AsyncGenerator#next is Promise, so in quansync we can use yield iter.next() to get IteratorResult.

[sxzz]

Here is a demo.

async function* asyncGen() {
  yield await 1
  yield await 2
}
function* syncGen() {
  yield 1
  yield 2
}

const asyncIter = asyncGen()
const syncIter = syncGen()

const fn = quansync(function* (iter: AsyncGenerator<number> | Generator<number>) {
  let result: IteratorResult<number>

  do {
    result = (yield iter.next()) as any
    if (!result.done) {
      console.log(result.value)
    }
  } while (!result.done)
})

await fn(asyncIter)
fn.sync(syncIter)

For type safety, please consider using unplugin

[rauschma]

Nice!

Maybe (minor changes):

const fn = quansync(function* (iter: AsyncIterator<number> | Iterator<number>) {
  while (true) {
    const result = (yield iter.next()) as IteratorResult<number>;
    if (result.done) break;
    console.log(result.value)
  }
})

• I’d find this example useful as documentation (in the readme or somewhere else).
• What about producing iterables? Maybe via a queue data structure?

[sxzz]

Could you please provide an example about producing iterables?

[rauschma]

/**
 * Chunks to lines via async iterable
 * 
 * Can be used for
 * - native Node.js streams
 * - web streams (Node’s or making them iterable via a helper)
 *   - for web streams, you can also use `ChunksToLinesTransformer`
 * 
 * @param chunkIterable An asynchronous or synchronous iterable
 * over “chunks” (arbitrary strings)
 * @returns An asynchronous iterable over “lines”
 * (strings with at most one newline that always appears at the end)
 */
export async function* chunksToLinesAsync(chunkIterable: AsyncIterable<string> | Iterable<string>): AsyncIterable<string> {
  let previous = '';
  for await (const chunk of chunkIterable) {
    let startSearch = previous.length;
    previous += chunk;
    while (true) {
      const eolIndex = previous.indexOf('\n', startSearch);
      if (eolIndex < 0) break;
      // line includes the EOL
      const line = previous.slice(0, eolIndex + 1);
      yield line;
      previous = previous.slice(eolIndex + 1);
      startSearch = 0;
    }
  }
  if (previous.length > 0) {
    yield previous;
  }
}

[wangziling]

Hmmm... Did you mean that it could record every yield value?

Currently the quansync only yield once - The symbol Symbol(quansync.getIsAsync).

[sxzz]

Great example! I’m still unsure about it, though… 🤔

[rauschma]

Not sure about the types, but I was thinking two versions (sync and async) of a queue into which you add elements: https://github.com/rauschma/helpers/blob/main/src/async/async-queue.ts

The queues would be synchronously and asynchronously iterable and could be returned.

[sxzz]

Understood, but currently, it seems impossible to achieve through Quansync. I can't think of a good solution at the moment.