pooledMapSettled

function · experimental

function pooledMapSettled<T, R>(array: Iterable<T> | AsyncIterable<T>, iteratorFn: (data: T) => R | Promise<R>, options: PooledMapSettledOptions): AsyncIterableIterator<PromiseSettledResult<R>>

Like pooledMap, but does not fail fast. Every item is processed regardless of earlier failures. Results are yielded as PromiseSettledResult objects in input order.

The relationship to pooledMap mirrors Promise.allSettled vs Promise.all.

If the input iterable itself throws, all currently executing items are allowed to finish and their settled results are yielded, then the iterator rejects with the original error from the input iterable.

The pool applies no backpressure: items are processed at full concurrency regardless of how quickly results are read, and completed results are buffered until consumed.

array: Iterable<T> | AsyncIterable<T>

The input iterable.

iteratorFn: (data: T) => R | Promise<R>

The transform function (sync or async).

options: PooledMapSettledOptions

Configuration for concurrency and cancellation.

Returns

An async iterator yielding PromiseSettledResult<R> for each item, in the order items were yielded from the input.

import { pooledMapSettled } from "@ende/async/unstable-pool-settled";
import { assertEquals } from "@ende/assert";

const results = pooledMapSettled(
  [1, 2, 3],
  (i) => {
    if (i === 2) throw new Error("bad");
    return Promise.resolve(i);
  },
  { poolLimit: 2 },
);

const settled = await Array.fromAsync(results);
assertEquals(settled.length, 3);
assertEquals(settled[0], { status: "fulfilled", value: 1 });
assertEquals(settled[1]!.status, "rejected");
assertEquals(settled[2], { status: "fulfilled", value: 3 });

import { pooledMapSettled } from "@ende/async/unstable-pool-settled";

const results = pooledMapSettled([1, 2, 3], async (i) => {
  await new Promise((r) => setTimeout(r, 1000));
  return i;
}, { poolLimit: 2, signal: AbortSignal.timeout(5_000) });

for await (const result of results) {
  console.log(result);
}