Partial rename to async

Author: nicolas-van

modern-async.d.ts

@@ -58,9 +58,9 @@ declare module "Queue" {
         cancelAllPending(): number;
     }
 }
-declare module "every" {
-    export default every;
-    function every<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<boolean>;
+declare module "asyncEvery" {
+    export default asyncEvery;
+    function asyncEvery<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<boolean>;
     import Queue from "Queue";
 }
 declare module "toArray" {
@@ -77,9 +77,9 @@ declare module "filterGenerator" {
     function filterGenerator<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number, ordered?: boolean): AsyncIterable<V>;
     import Queue from "Queue";
 }
-declare module "filter" {
-    export default filter;
-    function filter<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<V[]>;
+declare module "asyncFilter" {
+    export default asyncFilter;
+    function asyncFilter<V>(iterable: Iterable<V> | AsyncIterable<V>, iteratee: (value: V, index: number, iterable: Iterable<V> | AsyncIterable<V>) => Promise<boolean> | boolean, queueOrConcurrency?: Queue | number): Promise<V[]>;
     import Queue from "Queue";
 }
 declare module "find" {
@@ -177,8 +177,8 @@ declare module "modern-async" {
     export { default as delay } from "delay";
     export { default as delayCancellable } from "delayCancellable";
     export { default as Delayer } from "Delayer";
-    export { default as every } from "every";
-    export { default as filter } from "filter";
+    export { default as asyncEvery } from "asyncEvery";
+    export { default as asyncFilter } from "asyncFilter";
     export { default as filterGenerator } from "filterGenerator";
     export { default as find } from "find";
     export { default as findIndex } from "findIndex";

src/every.mjs renamed to src/asyncEvery.mjs

@@ -29,11 +29,11 @@ import findIndex from './findIndex.mjs'
  * if a least one of them doesn't pass it. That promise will be rejected if one of the truth test throws
  * an exception.
  * @example
- * import { every, sleep } from 'modern-async'
+ * import { asyncEvery, sleep } from 'modern-async'
  *
  * const array = [1, 2, 3]
  *
- * const result = await every(array, async (v) => {
+ * const result = await asyncEvery(array, async (v) => {
  *   // these calls will be performed in parallel with a maximum of 2
  *   // concurrent calls
  *   await sleep(10) // waits 10ms
@@ -42,7 +42,7 @@ import findIndex from './findIndex.mjs'
  * console.log(result) // prints true
  * // total processing time should be ~ 20ms
  */
-async function every (iterable, iteratee, queueOrConcurrency = 1) {
+async function asyncEvery (iterable, iteratee, queueOrConcurrency = 1) {
   assert(typeof iteratee === 'function', 'iteratee must be a function')
   iteratee = asyncWrap(iteratee)
   const index = await findIndex(iterable, async (value, index, iterable) => {
@@ -52,4 +52,4 @@ async function every (iterable, iteratee, queueOrConcurrency = 1) {
   return result
 }
 
-export default every
+export default asyncEvery

src/every.test.mjs renamed to src/asyncEvery.test.mjs

@@ -1,100 +1,100 @@
 
 import { expect, test } from '@jest/globals'
-import every from './every.mjs'
+import asyncEvery from './asyncEvery.mjs'
 import Deferred from './Deferred.mjs'
 import { range } from 'itertools'
 import delay from './delay.mjs'
 
 // eslint-disable-next-line require-jsdoc
 class TestError extends Error {}
 
-test('every compatibility', async () => {
+test('asyncEvery compatibility', async () => {
   let d = new Deferred()
-  let p = every([...range(3)], async (v) => {
+  let p = asyncEvery([...range(3)], async (v) => {
     await d.promise
     return true
   }, 1)
   d.resolve()
   expect(await p).toBe([...range(3)].every((v) => true))
 
   d = new Deferred()
-  p = every([...range(3)], async (v) => {
+  p = asyncEvery([...range(3)], async (v) => {
     await d.promise
     return v !== 2
   }, 1)
   d.resolve()
   expect(await p).toBe([...range(3)].every((v) => v !== 2))
 
   d = new Deferred()
-  p = every([...range(3)], async (v) => {
+  p = asyncEvery([...range(3)], async (v) => {
     await d.promise
     return false
   }, 1)
   d.resolve()
   expect(await p).toBe([...range(3)].every((v) => false))
 
   d = new Deferred()
-  p = every([], async (v) => {
+  p = asyncEvery([], async (v) => {
     await d.promise
     return false
   }, 1)
   d.resolve()
   expect(await p).toBe([].every((v) => false))
 
   d = new Deferred()
-  p = every([], async (v) => {
+  p = asyncEvery([], async (v) => {
     await d.promise
     return true
   }, 1)
   d.resolve()
   expect(await p).toBe([].every((v) => true))
 })
 
-test('every parallel', async () => {
+test('asyncEvery parallel', async () => {
   let d = new Deferred()
-  let p = every([...range(3)], async (v) => {
+  let p = asyncEvery([...range(3)], async (v) => {
     await d.promise
     return true
   }, 10)
   d.resolve()
   expect(await p).toBe([...range(3)].every((v) => true))
 
   d = new Deferred()
-  p = every([...range(3)], async (v) => {
+  p = asyncEvery([...range(3)], async (v) => {
     await d.promise
     return v !== 2
   }, 10)
   d.resolve()
   expect(await p).toBe([...range(3)].every((v) => v !== 2))
 
   d = new Deferred()
-  p = every([...range(3)], async (v) => {
+  p = asyncEvery([...range(3)], async (v) => {
     await d.promise
     return false
   }, 10)
   d.resolve()
   expect(await p).toBe([...range(3)].every((v) => false))
 
   d = new Deferred()
-  p = every([], async (v) => {
+  p = asyncEvery([], async (v) => {
     await d.promise
     return false
   }, 10)
   d.resolve()
   expect(await p).toBe([].every((v) => false))
 
   d = new Deferred()
-  p = every([], async (v) => {
+  p = asyncEvery([], async (v) => {
     await d.promise
     return true
   }, 10)
   d.resolve()
   expect(await p).toBe([].every((v) => true))
 })
 
-test('every first in time', async () => {
+test('asyncEvery first in time', async () => {
   const ds = [...range(3)].map(() => new Deferred())
-  const p = every(range(3), async (v, i) => {
+  const p = asyncEvery(range(3), async (v, i) => {
     await ds[i]
     return false
   }, 3)
@@ -103,9 +103,9 @@ test('every first in time', async () => {
   expect(res).toBe(false)
 })
 
-test('every error', async () => {
+test('asyncEvery error', async () => {
   const callList = [...range(3)].map(() => 0)
-  const p = every([...range(3)], async (v, i) => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     callList[i] += 1
     if (i === 1) {
       throw new TestError()
@@ -124,12 +124,12 @@ test('every error', async () => {
   expect(callList[2]).toStrictEqual(0)
 })
 
-test('every infinite concurrency all pass', async () => {
+test('asyncEvery infinite concurrency all pass', async () => {
   const callCount = {}
   ;[...range(3)].forEach((i) => { callCount[i] = 0 })
   const d = new Deferred()
   const ds = [...range(3)].map(() => new Deferred())
-  const p = every([...range(3)], async (v, i) => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     callCount[i] += 1
     ds[i].resolve()
     await d.promise
@@ -147,12 +147,12 @@ test('every infinite concurrency all pass', async () => {
   expect(callCount[2]).toBe(1)
 })
 
-test('every infinite concurrency no all pass', async () => {
+test('asyncEvery infinite concurrency no all pass', async () => {
   const callCount = {}
   ;[...range(3)].forEach((i) => { callCount[i] = 0 })
   const d = new Deferred()
   const ds = [...range(3)].map(() => new Deferred())
-  const p = every([...range(3)], async (v, i) => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     callCount[i] += 1
     ds[i].resolve()
     await d.promise
@@ -174,8 +174,8 @@ test('every infinite concurrency no all pass', async () => {
   expect(callCount[2]).toBe(1)
 })
 
-test('every infinite concurrency error', async () => {
-  const p = every([...range(3)], async (v, i) => {
+test('asyncEvery infinite concurrency error', async () => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     if (i === 1) {
       throw new TestError()
     }
@@ -191,12 +191,12 @@ test('every infinite concurrency error', async () => {
   await delay()
 })
 
-test('every concurrency 1 all pass', async () => {
+test('asyncEvery concurrency 1 all pass', async () => {
   const callCount = {}
   ;[...range(3)].forEach((i) => { callCount[i] = 0 })
   const d = new Deferred()
   const ds = [...range(3)].map(() => new Deferred())
-  const p = every([...range(3)], async (v, i) => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     callCount[i] += 1
     ds[i].resolve()
     await d.promise
@@ -214,12 +214,12 @@ test('every concurrency 1 all pass', async () => {
   expect(callCount[2]).toBe(1)
 })
 
-test('every concurrency 1 no all pass', async () => {
+test('asyncEvery concurrency 1 no all pass', async () => {
   const callCount = {}
   ;[...range(3)].forEach((i) => { callCount[i] = 0 })
   const d = new Deferred()
   const ds = [...range(3)].map(() => new Deferred())
-  const p = every([...range(3)], async (v, i) => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     callCount[i] += 1
     ds[i].resolve()
     await d.promise
@@ -241,9 +241,9 @@ test('every concurrency 1 no all pass', async () => {
   expect(callCount[2]).toBe(0)
 })
 
-test('every concurrency 1 error', async () => {
+test('asyncEvery concurrency 1 error', async () => {
   const callList = [...range(3)].map(() => 0)
-  const p = every([...range(3)], async (v, i) => {
+  const p = asyncEvery([...range(3)], async (v, i) => {
     callList[i] += 1
     if (i === 1) {
       throw new TestError()

src/filter.mjs renamed to src/asyncFilter.mjs

@@ -24,10 +24,10 @@ import filterGenerator from './filterGenerator.mjs'
  * @returns {Promise<any[]>} A promise that will be resolved with an array containing all the values that passed
  * the truth test. This promise will be rejected if any of the `iteratee` calls throws an exception.
  * @example
- * import { filter, sleep } from 'modern-async'
+ * import { asyncFilter, sleep } from 'modern-async'
  *
  * const array = [1, 2, 3]
- * const result = await filter(array, async (v) => {
+ * const result = await asyncFilter(array, async (v) => {
  *   // these calls will be performed in parallel with a maximum of 2
  *   // concurrent calls
  *   await sleep(10) // waits 10ms
@@ -36,8 +36,8 @@ import filterGenerator from './filterGenerator.mjs'
  * console.log(result) // prints [1, 3]
  * // total processing time should be ~ 20ms
  */
-async function filter (iterable, iteratee, queueOrConcurrency = 1) {
+async function asyncFilter (iterable, iteratee, queueOrConcurrency = 1) {
   return await toArray(filterGenerator(iterable, iteratee, queueOrConcurrency))
 }
 
-export default filter
+export default asyncFilter