fix(Async): use for of loop instead of reduce in async fns

.changeset/wise-cows-fix.md

@@ -0,0 +1,5 @@
+---
+"@opentf/std": minor
+---
+
+Fixed async fns not awaiting within cb fn.

README.md

@@ -114,9 +114,9 @@ await sleep(1000); // It suspends the exection for 1 second.
 
 ## Async
 
-- [asyncFilter](https://js-std.pages.dev/Array/asyncFilter)
-- [asyncForEach](https://js-std.pages.dev/Array/asyncForEach)
-- [asyncMap](https://js-std.pages.dev/Array/asyncMap)
+- [aFilter](https://js-std.pages.dev/Async/aFilter)
+- [aForEach](https://js-std.pages.dev/Async/aForEach)
+- [aMap](https://js-std.pages.dev/Async/aMap)
 
 ### Maths
 

apps/docs/pages/Async/_meta.json

@@ -1,5 +1,5 @@
 {
-  "asyncFilter": "asyncFilter",
-  "asyncForEach": "asyncForEach",
-  "asyncMap": "asyncMap"
+  "aFilter": "aFilter",
+  "aForEach": "aForEach",
+  "aMap": "aMap"
 }

apps/docs/pages/Async/asyncFilter.mdx → apps/docs/pages/Async/aFilter.mdx

@@ -5,7 +5,7 @@ import REPL from "../../components/REPL";
 ## Syntax
 
 ```ts
-asyncFilter(
+aFilter(
   arr: T[], 
   cb: (value: T, index: number) => Promise<boolean>
 ): Promise<Partial<T[]>>
@@ -14,9 +14,9 @@ asyncFilter(
 ## Usage
 
 ```ts
-import { asyncFilter } from "@opentf/std";
+import { aFilter } from "@opentf/std";
 
-asyncFilter([], async (value, index) => {});
+aFilter([], async (value, index) => {});
 ```
 
 ## Examples
@@ -30,14 +30,14 @@ function isEven(n) {
   });
 }
 
-const filteredArr = await asyncFilter(arr, async (n) => await isEven(n));
+const filteredArr = await aFilter(arr, async (n) => await isEven(n));
 
 console.log(filteredArr); //=> [2, 4]
 ```
 
 ## Try
 
-<REPL code={`const { asyncFilter } = require('@opentf/std');
+<REPL code={`const { aFilter } = require('@opentf/std');
 
 function isEven(n) {
   return new Promise((resolve) => {
@@ -47,7 +47,7 @@ function isEven(n) {
 
 async function main() {
   const arr = [1, 2, 3, 4, 5];
-  const out = await asyncFilter(arr, async (n) => await isEven(n));
+  const out = await aFilter(arr, async (n) => await isEven(n));
   log(out);
 }
 

apps/docs/pages/Async/asyncForEach.mdx → apps/docs/pages/Async/aForEach.mdx

@@ -5,7 +5,7 @@ import REPL from "../../components/REPL";
 ## Syntax
 
 ```ts
-asyncForEach(
+aForEach(
   arr: T[], 
   cb: (value: T, index: number) => Promise<void>
 ): Promise<undefined>
@@ -14,9 +14,9 @@ asyncForEach(
 ## Usage
 
 ```ts
-import { asyncForEach } from "@opentf/std";
+import { aForEach } from "@opentf/std";
 
-asyncForEach([], async (value, index) => {});
+aForEach([], async (value, index) => {});
 ```
 
 ## Examples
@@ -30,7 +30,7 @@ const flatten = async (val) => {
 
 const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]];
 const tmpArr = [];
-await asyncForEach(nested, async (n) => {
+await aForEach(nested, async (n) => {
   const val = await flatten(n);
   Array.isArray(val) ? tmpArr.push(...val) : tmpArr.push(val);
 });
@@ -39,7 +39,7 @@ console.log(tmpArr) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 ## Try
 
-<REPL code={`const { asyncForEach } = require('@opentf/std');
+<REPL code={`const { aForEach } = require('@opentf/std');
 
 const flatten = async (val) => {
   return new Promise((resolve) => {
@@ -51,7 +51,7 @@ const flatten = async (val) => {
 async function main() {
   const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]];
   const tmpArr = [];
-  await asyncForEach(nested, async (n) => {
+  await aForEach(nested, async (n) => {
     const val = await flatten(n);
     Array.isArray(val) ? tmpArr.push(...val) : tmpArr.push(val);
   });

apps/docs/pages/Async/asyncMap.mdx → apps/docs/pages/Async/aMap.mdx

@@ -5,7 +5,7 @@ import REPL from "../../components/REPL";
 ## Syntax
 
 ```ts
-asyncMap(
+aMap(
   arr: T[], 
   cb: (value: T, index: number) => Promise<unknown>
 ): Promise<unknown[]>
@@ -14,9 +14,9 @@ asyncMap(
 ## Usage
 
 ```ts
-import { asyncMap } from "@opentf/std";
+import { aMap } from "@opentf/std";
 
-asyncMap([], async (value, index) => {});
+aMap([], async (value, index) => {});
 ```
 
 ## Examples
@@ -30,13 +30,13 @@ function multiply(n, i) {
   });
 }
 
-const result = await asyncMap(arr, async (n, i) => await multiply(n, i));
+const result = await aMap(arr, async (n, i) => await multiply(n, i));
 console.log(result); // [0, 2, 6, 12, 20]
 ```
 
 ## Try
 
-<REPL code={`const { asyncMap } = require('@opentf/std');
+<REPL code={`const { aMap } = require('@opentf/std');
 
 function multiply(n, i) {
   return new Promise((resolve) => {
@@ -47,7 +47,7 @@ function multiply(n, i) {
 
 async function main() {
   const arr = [1, 2, 3, 4, 5];
-  const result = await asyncMap(arr, async (n, i) => await multiply(n, i));
+  const result = await aMap(arr, async (n, i) => await multiply(n, i));
   log(result);
 }
 

packages/std/README.md

@@ -114,9 +114,9 @@ await sleep(1000); // It suspends the exection for 1 second.
 
 ## Async
 
-- [asyncFilter](https://js-std.pages.dev/Array/asyncFilter)
-- [asyncForEach](https://js-std.pages.dev/Array/asyncForEach)
-- [asyncMap](https://js-std.pages.dev/Array/asyncMap)
+- [aFilter](https://js-std.pages.dev/Async/aFilter)
+- [aForEach](https://js-std.pages.dev/Async/aForEach)
+- [aMap](https://js-std.pages.dev/Async/aMap)
 
 ### Maths
 

packages/std/__tests__/async/asyncFilter.spec.js → packages/std/__tests__/async/aFilter.spec.ts

@@ -1,7 +1,7 @@
-import { asyncFilter } from '../../src';
+import { aFilter } from '../../src';
 
-describe('Array', () => {
-  test('asyncFilter', async () => {
+describe('Array > aFilter', () => {
+  test('filters only even numbers', async () => {
     const arr = [1, 2, 3, 4, 5];
 
     function isEven(n) {
@@ -10,7 +10,7 @@ describe('Array', () => {
       });
     }
 
-    const filteredArr = await asyncFilter(arr, async (n) => await isEven(n));
+    const filteredArr = await aFilter(arr, async (n) => await isEven(n));
 
     expect(filteredArr).toEqual([2, 4]);
   });

packages/std/__tests__/async/asyncForEach.spec.ts → packages/std/__tests__/async/aForEach.spec.ts

@@ -1,7 +1,7 @@
-import { asyncForEach } from '../../src';
+import { aForEach } from '../../src';
 
-describe('Array', () => {
-  test('asyncForEach', async () => {
+describe('Array > aForEach', () => {
+  test('async fn in cb fn', async () => {
     const flatten = async (val) => {
       return new Promise((resolve) => {
         Array.isArray(val) ? resolve(val.flat()) : resolve(val);
@@ -10,10 +10,17 @@ describe('Array', () => {
 
     const nested = [1, 2, 3, [4, 5, [6, 7], 8, 9]];
     const tmpArr = [];
-    await asyncForEach(nested, async (n) => {
+    await aForEach(nested, async (n) => {
       const val = await flatten(n);
       Array.isArray(val) ? tmpArr.push(...val) : tmpArr.push(val);
     });
     expect(tmpArr).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
   });
+
+  test('cb fn index', async () => {
+    const arr = [1, 2, 3];
+    const out = [];
+    await aForEach(arr, (_e, i) => out.push(i));
+    expect(out).toEqual([0, 1, 2]);
+  });
 });

packages/std/__tests__/async/asyncMap.spec.ts → packages/std/__tests__/async/aMap.spec.ts

@@ -1,7 +1,7 @@
-import { asyncMap } from '../../src';
+import { aMap, sleep } from '../../src';
 
-describe('Array', () => {
-  test('asyncMap', async () => {
+describe('Array > aMap', () => {
+  test('async map', async () => {
     const arr = [1, 2, 3, 4, 5];
 
     function multiply(n, i) {
@@ -10,7 +10,8 @@ describe('Array', () => {
       });
     }
 
-    const result = await asyncMap(arr, async (n, i) => await multiply(n, i));
+    const result = await aMap(arr, async (n, i) => await multiply(n, i));
+
     expect(result).toEqual([0, 2, 6, 12, 20]);
   });
 });

packages/std/src/async/aFilter.ts

@@ -0,0 +1,24 @@
+/**
+ *  Array filter with `Async` callback function.
+ *
+ * @example
+ *
+ * const arr = [1, 2, 3]
+ * aFilter(arr, (n) => isOdd(n)) //=> [1, 3]
+ */
+export default async function aFilter<T>(
+  arr: T[],
+  cb: (value: T, index: number) => Promise<boolean>
+): Promise<Partial<T[]>> {
+  let i = 0;
+  const out = [];
+
+  for (const e of arr) {
+    if (await cb(e, i)) {
+      out.push(e);
+    }
+    i++;
+  }
+
+  return out;
+}

packages/std/src/async/aForEach.ts

@@ -0,0 +1,18 @@
+/**
+ *  Array forEach with `Async` callback function.
+ *
+ * @example
+ *
+ * await aForEach([1, 3, 5], async () => await someDelayedFn())
+ */
+export default async function aForEach<T>(
+  arr: T[],
+  cb: (value: T, index: number) => Promise<void>
+): Promise<undefined> {
+  let i = 0;
+
+  for (const e of arr) {
+    await cb(e, i);
+    i++;
+  }
+}

packages/std/src/async/aMap.ts

@@ -0,0 +1,20 @@
+/**
+ *  Array map with `Async` callback function.
+ *
+ * @example
+ * await aMap([1, 2, 3], (n) => await someDelayedFn(n))
+ */
+export default async function aMap<T>(
+  arr: T[],
+  cb: (value: T, index: number) => Promise<unknown>
+): Promise<unknown[]> {
+  let i = 0;
+  const out: unknown[] = [];
+
+  for (const e of arr) {
+    out.push(await cb(e, i));
+    i++;
+  }
+
+  return out;
+}

packages/std/src/index.ts

@@ -32,9 +32,9 @@ export { default as drop } from './array/drop';
 export { default as intersperse } from './array/intersperse';
 
 // Async
-export { default as asyncFilter } from './async/asyncFilter';
-export { default as asyncMap } from './async/asyncMap';
-export { default as asyncForEach } from './async/asyncForEach';
+export { default as aFilter } from './async/aFilter';
+export { default as aMap } from './async/aMap';
+export { default as aForEach } from './async/aForEach';
 
 // Maths
 export { default as percentage } from './maths/percentage';