any - API reference

API reference › @evolu/common › Task › any

function any<TTasks>(
  tasks: TTasks,
  options?: TaskCollectionOptions,
): Task<
  InferTaskOk<TTasks[number]>,
  InferTaskErr<TTasks[number]>,
  ParameterIntersection<
    TTasks[number] extends TTask
      ? TTask extends AnyTask
        ? (deps: InferTaskDeps<TTask>) => void
        : never
      : never
  >
>;

Defined in: packages/common/src/Task.ts:4249

Runs Tasks until one returns Ok or all return Err.

Use race to return the first settled Result instead, whether Ok or Err.

Returns the first Ok Result. Queued Tasks are not started, and other running Tasks are aborted. If no Task returns Ok, returns the last Err by input order, regardless of completion order. Other Err results are discarded; use allSettled when you need every error.

Sequential by default; pass a concurrency option to run more than one Task at a time.

Similar to Promise.any, but runs Tasks, returns Result values, and stops after the first Ok.

Example

import {
  assertOk,
  assertType,
  assertTrue,
  any,
  createRun,
  err,
  ok,
  type Result,
  type Task,
  type Typed,
} from "@evolu/common";

const unavailable: Task<string, ServiceUnavailableError> = () =>
  err({ type: "ServiceUnavailable" });

interface ServiceUnavailableError extends Typed<"ServiceUnavailable"> {}

let fallbackStarted = false;
const fallback: Task<string> = () => {
  fallbackStarted = true;
  return ok("fallback");
};

await using run = createRun();
const result = await run(any([unavailable, fallback]));

assertType<Result<string, ServiceUnavailableError>, typeof result>();
assertOk(result, "fallback");
assertTrue(fallbackStarted);