AsyncIter: Better AsyncIterables for Deno

I just want to work with AsyncIterable collections without using for loops. Is that so wrong?

This little library exposes both functions and a fluent-style wrapper so I can write my lazy code the way I want to: lazily.

It also supports easy in-order and out-of-order concurrent execution - with limits.

Quickstart

Here are some simple examples to get you started.

Convert an `Array` to `AsyncIterable`

const iter = asynciter([1, 2, 3]);
for await (const it of iter) {
  console.log(it);
}

map

console.dir(await asynciter([1, 2, 3]).map((it) => it * 2).collect());
// [ 2, 4, 6 ]

concurrent-map.ts

There are four items in the array, but the operation will run in about two seconds because the operation is concurrent.

function delayedDouble(delay: number): (n: number) => Promise<string> {
  return (n: number) =>
    new Promise((resolve, _reject) => {
      setTimeout(() => {
        resolve(2 * n);
      }, delay);
    });
}

await asynciter([1, 2, 3, 4]).concurrentMap(
  delayedDouble(1000),
  2,
).collect();

// [2, 4, 6, 8]

filter

console.dir(await asynciter([1, 2, 3]).filter((it) => it > 1).collect());
// [ 2, 3 ]

reduce

console.dir(await asynciter([1, 2, 3]).reduce(0, (a, b) => a + b));
// 6

forEach

await asynciter([1, 2, 3]).forEach((it) => console.log(it));
// 1
// 2
// 3

first

const iter = asynciter([1, 2, 3]);
console.dir(await iter.first());
console.dir(await iter.first());
// 1
// null

collect

console.dir(await asynciter([1, 2, 3]).collect());
// [ 1, 2, 3 ]