feat(asyncScanOnce): add asyncScanOnce function

Author: djcsdy

index.test.ts

@@ -42,6 +42,7 @@ import {
     asyncPushOnce,
     asyncRemoveFirstOnce,
     asyncRemoveOnce,
+    asyncScanOnce,
     asyncSliceOnce,
     asyncSumOnce,
     asyncTailOnce,
@@ -589,3 +590,16 @@ test("asyncNoneNullOnce", async t => {
     t.is(await asyncNoneNullOnce(asyncIterator([undefined, 2, 3])), null);
     t.deepEqual(await asyncNoneNullOnce(asyncIterator([])), []);
 });
+
+test("asyncScanOnce", async t => {
+    t.deepEqual(
+        await asyncToArrayOnce(asyncScanOnce(asyncIterator([1, 2, 3]), (a, e, i) => a + e * i, 0)),
+        [0, 2, 8]
+    );
+    t.deepEqual(
+        await asyncToArrayOnce(
+            asyncScanOnce(asyncIterator(["a", "b", "c"]), (a, e, i) => `${a} ${i} ${e}`, "_")
+        ),
+        ["_ 0 a", "_ 0 a 1 b", "_ 0 a 1 b 2 c"]
+    );
+});

index.ts

@@ -1071,3 +1071,33 @@ export async function asyncNoneNullOnce<T>(
     }
     return array;
 }
+
+export function asyncScanOnce<T, U>(
+    iterator: AsyncIteratorLike<T>,
+    f: (accumulator: U, element: T, index: number) => U | Promise<U>,
+    initial: U
+): AsyncIterator<U> {
+    const it = asyncIterator(iterator);
+    let i = 0;
+    const during = (accumulator: U) => async (): Promise<IteratorResult<U>> => {
+        const element = await it.next();
+        if (element.done === true) {
+            next = after;
+            return after();
+        } else {
+            const value = await f(accumulator, element.value, i++);
+            next = during(value);
+            return {value};
+        }
+    };
+    const after = async (): Promise<IteratorResult<U>> => ({done: true, value: undefined});
+    let next = during(initial);
+    return {next: async () => next()};
+}
+
+export function asyncScanOnceFn<T, U>(
+    f: (accumulator: U, element: T, index: number) => U | Promise<U>,
+    initial: U
+): (iterator: AsyncIteratorLike<T>) => AsyncIterator<U> {
+    return iterator => asyncScanOnce(iterator, f, initial);
+}