Implement Promise.any

The question

Almost always straight after Promise.all, because it’s the mirror image and the contrast is the point. Two details carry the marks: rejecting with an AggregateError rather than a plain Error, and rejecting empty input immediately instead of hanging.

The solution

Structurally the inverse of Promise.all: success short-circuits, failure accumulates.

function promiseAny(iterable) {
  return new Promise((resolve, reject) => {
    const items = Array.from(iterable);
    const errors = new Array(items.length);
    let remaining = items.length;

    if (remaining === 0) {
      reject(new AggregateError([], "All promises were rejected"));
      return;
    }

    items.forEach((item, index) => {
      Promise.resolve(item).then(resolve, (error) => {
        // Reasons are reported in input order, not rejection order.
        errors[index] = error;
        remaining -= 1;
        if (remaining === 0) {
          reject(new AggregateError(errors, "All promises were rejected"));
        }
      });
    });
  });
}

How it works

• resolve is passed straight through as the fulfilment handler, so the first success settles the outer promise and every later one is ignored.
• Errors are stored by index, so error.errors reports them in input order rather than the order they happened to fail.
• The counter reaching zero means everything rejected, which is the only condition under which Promise.any rejects.
• Empty input rejects immediately with an AggregateError and no errors, which is what the specification requires and what the medium test checks.

The tests it has to pass

This is the part most explanations leave out. "It works" is not a claim you can check by reading. These are the 4 cases Practice Pad runs against your solution, and the implementation above passes all of them.

const winner = await promiseAny([
  new Promise((resolve) => setTimeout(() => { resolve("later"); }, 40)),
  Promise.resolve("cached"),
]);
expectEqual(winner, "cached");

const at = (ms, value) => new Promise((resolve) => setTimeout(() => { resolve(value); }, ms));
expectEqual(await promiseAny([at(60, "slow"), at(10, "quick"), at(40, "middle")]), "quick");

let isAggregate = false;
try {
  await promiseAny([]);
} catch (error) {
  isAggregate = error instanceof AggregateError;
}
expectEqual(isAggregate, true);

let messages;
try {
  await promiseAny([Promise.reject(new Error("first")), Promise.reject(new Error("second"))]);
} catch (error) {
  if (error instanceof AggregateError) {
    messages = error.errors.map((item) => (item instanceof Error ? item.message : "?"));
  }
}
expectEqual(messages, ["first", "second"]);

Edge cases to watch out for

Rejecting with a plain Error

The specification is specific: it must be an AggregateError, whose errors property holds every reason. The test does an instanceof check, and so do real callers.

Resolving empty input instead of rejecting

Promise.all([]) fulfils with [], which makes people assume Promise.any([]) does something similar. It rejects, because no input fulfilled and none ever will.

Collecting errors in rejection order

Pushing as they arrive gives you the order they failed in, which isn’t the input order the specification promises. Assign by index.

Confusing it with Promise.race

race settles with the first promise to settle either way, so a fast rejection wins. any ignores rejections until every one has failed. They behave identically only when the first settlement is a success.

Follow up questions

See all 24 questions