[API reference](https://evolu.dev/docs/api-reference) › [@evolu/common](https://evolu.dev/docs/api-reference/common) › [Task](https://evolu.dev/docs/api-reference/common/Task) › race

```ts
function race<TTasks>(
  tasks: TTasks,
): 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:4178](https://github.com/evoluhq/evolu/blob/a18269a1b822c670b507c6a9b73b23eed32551fe/packages/common/src/Task.ts#L4178)

Runs Tasks until the first Task settles.

Returns the first Task [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result) to settle, whether [Ok](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) or
[Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/Err).

Use [any](https://evolu.dev/docs/api-reference/common/Task/functions/any) to wait for the first Ok instead.

Losing Tasks are aborted.

Tasks always run concurrently because racing sequentially would be
meaningless.

Similar to
[Promise.race](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race),
but races Tasks, returns Result values, and aborts losers.

Requires a non-empty array: zero Tasks have no meaningful first settled
Result. This is enforced at compile time for non-empty tuple types. For
arrays whose emptiness is only known at runtime, guard with
[isNonEmptyArray](https://evolu.dev/docs/api-reference/common/Array/functions/isNonEmptyArray):

### Example

```ts

const tasks: ReadonlyArray<Task<string>> = [() => ok("first")];
await using run = createRun();
if (isNonEmptyArray(tasks)) {
  const result = await run(race(tasks));
  expectOk(result, "first");
}
```

### Example

```ts
import {
  createRun,
  ok,
  race,
  sleep,
  type Result,
  type Task,
} from "@evolu/common";

await using run = createRun();

const fast: Task<string> = () => ok("fast");
let slowCompleted = false;
const slow: Task<string> = async (run) => {
  await run.ok(sleep("10ms"));
  slowCompleted = true;
  return ok("slow");
};

// Input order does not matter: the first settled Result wins, and the
// still-running loser is aborted.
const result = await run(race([slow, fast]));
expectTypeOf(result).toEqualTypeOf<Result<string>>();
expectOk(result, "fast");
expect(slowCompleted).toBe(false);
```