allResult - API reference

API reference › @evolu/common › Result › allResult

Call Signature

function allResult<T>(
  results: T,
): Result<
  { [K in string | number | symbol]: InferOk<T[K]> },
  InferErr<T[number]>
>;

Defined in: packages/common/src/Result.ts:995

Collects successful values from Results.

Stops processing the input at the first Err. Mapping overloads do not call the mapper for the remaining input values.

Pass { collect: false } to return Result<void, E> without storing the Ok values in an output collection.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
  type Typed,
} from "@evolu/common";

const getCount = (): Result<number, CountUnavailableError> => ok(2);

interface CountUnavailableError extends Typed<"CountUnavailable"> {}

const getLabel = (): Result<string, LabelUnavailableError> => ok("books");

interface LabelUnavailableError extends Typed<"LabelUnavailable"> {}

const values = allResult([getCount(), getLabel()]);
assertType<
  Result<
    readonly [number, string],
    CountUnavailableError | LabelUnavailableError
  >,
  typeof values
>();
assertOk(values, [2, "books"]);

Call Signature

function allResult<T>(
  results: T,
): Result<
  { [P in string | number | symbol]: InferOk<T[P]> },
  [keyof T] extends [never] ? never : InferErr<T[keyof T]>
>;

Defined in: packages/common/src/Result.ts:1022

Returns an object with the same keys.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const resultsByName = { a: ok(1), b: ok(2) } as const;
const valuesByName = allResult(resultsByName);
assertType<
  Result<{ readonly a: number; readonly b: number }>,
  typeof valuesByName
>();
assertOk(valuesByName, { a: 1, b: 2 });

Call Signature

function allResult<T, E>(
  results: Iterable<Result<T, E>>,
): Result<readonly T[], E>;

Defined in: packages/common/src/Result.ts:1049

For dynamic or generated result lists.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const results: ReadonlyArray<Result<number>> = [ok(1), ok(2)];
const numbers = allResult(results);
assertType<Result<ReadonlyArray<number>>, typeof numbers>();
assertOk(numbers, [1, 2]);

Call Signature

function allResult<T, E>(
  results: readonly [Result<T, E>, Result<T, E>],
): Result<readonly [T, T], E>;

Defined in: packages/common/src/Result.ts:1074

Preserves a non-empty array on success.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type NonEmptyReadonlyArray,
  type Result,
} from "@evolu/common";

const results: NonEmptyReadonlyArray<Result<number>> = [ok(1), ok(2)];
const numbers = allResult(results);
assertType<Result<NonEmptyReadonlyArray<number>>, typeof numbers>();
assertOk(numbers, [1, 2]);

Call Signature

function allResult<T>(
  results: T,
  options: {
    collect: false;
  },
): Result<void, [keyof T] extends [never] ? never : InferErr<T[keyof T]>>;

Defined in: packages/common/src/Result.ts:1097

Does not collect the Ok values from a record of Results.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const result = allResult({ a: ok(1), b: ok(2) }, { collect: false });
assertType<Result<void>, typeof result>();
assertOk(result, undefined);

Call Signature

function allResult<R>(
  results: Iterable<R>,
  options: {
    collect: false;
  },
): Result<void, InferErr<R>>;

Defined in: packages/common/src/Result.ts:1125

Does not collect the Ok values from an iterable of Results.

Use this overload when the Results already exist and only their collective success or failure matters.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const results: ReadonlyArray<Result<number>> = [ok(1), ok(2)];
const result = allResult(results, { collect: false });
assertType<Result<void>, typeof result>();
assertOk(result, undefined);

Call Signature

function allResult<A, R>(
  values: A,
  fn: (value: A[number]) => R,
): Result<{ [K in string | number | symbol]: InferOk<R> }, InferErr<R>>;

Defined in: packages/common/src/Result.ts:1155

Maps a non-empty array or tuple to Results and preserves its shape.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type NonEmptyReadonlyArray,
  type Result,
} from "@evolu/common";

const numbers: NonEmptyReadonlyArray<number> = [1, 2];
const doubled = allResult(numbers, (number) => ok(number * 2));
assertType<Result<NonEmptyReadonlyArray<number>>, typeof doubled>();
assertOk(doubled, [2, 4]);

const tuple = allResult([1, 2] as const, (number) => ok(number * 2));
assertType<Result<readonly [number, number]>, typeof tuple>();
assertOk(tuple, [2, 4]);

Call Signature

function allResult<A, R>(
  values: Iterable<A>,
  fn: (value: A) => R,
): Result<readonly InferOk<R>[], InferErr<R>>;

Defined in: packages/common/src/Result.ts:1183

Maps a dynamic or generated value collection to Results.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const numbers: Iterable<number> = new Set([1, 2]);
const doubled = allResult(numbers, (number) => ok(number * 2));
assertType<Result<ReadonlyArray<number>>, typeof doubled>();
assertOk(doubled, [2, 4]);

Call Signature

function allResult<A, R, K>(
  values: Readonly<Record<K, A>>,
  fn: (value: A) => R,
): Result<Readonly<Record<K, InferOk<R>>>, InferErr<R>>;

Defined in: packages/common/src/Result.ts:1220

Maps record values to Results and preserves the record's keys.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

interface User {
  readonly id: string;
}

const toUser = (id: string): Result<User> => ok({ id });

const userIdsByRole = { owner: "user-1", reviewer: "user-2" } as const;
const usersByRole = allResult(userIdsByRole, toUser);
assertType<
  Result<Readonly<Record<"owner" | "reviewer", User>>>,
  typeof usersByRole
>();
assertOk(usersByRole, {
  owner: { id: "user-1" },
  reviewer: { id: "user-2" },
});

Call Signature

function allResult<A, R>(
  values: Iterable<A>,
  fn: (value: A) => R,
  options: {
    collect: false;
  },
): Result<void, InferErr<R>>;

Defined in: packages/common/src/Result.ts:1259

Maps values to Results without collecting their Ok values.

This avoids allocating the output collection even when the mapped operations return success values.

Example

import {
  allResult,
  assertEqual,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const visited: Array<number> = [];
const result = allResult(
  [1, 2],
  (number) => {
    visited.push(number);
    return ok(number * 2);
  },
  {
    collect: false,
  },
);
assertType<Result<void>, typeof result>();
assertOk(result, undefined);
assertEqual(visited, [1, 2]);

Call Signature

function allResult<A, R, K>(
  values: Readonly<Record<K, A>>,
  fn: (value: A) => R,
  options: {
    collect: false;
  },
): Result<void, InferErr<R>>;

Defined in: packages/common/src/Result.ts:1286

Maps record values to Results without collecting their Ok values.

Example

import {
  allResult,
  assertOk,
  assertType,
  ok,
  type Result,
} from "@evolu/common";

const result = allResult({ a: 1, b: 2 }, (number) => ok(number * 2), {
  collect: false,
});
assertType<Result<void>, typeof result>();
assertOk(result, undefined);