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

## Call Signature

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

Defined in: [packages/common/src/Result.ts:990](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L990)

Collects successful values from [Result](https://evolu.dev/docs/api-reference/common/Result/type-aliases/Result)s.

Stops processing the input at the first [Err](https://evolu.dev/docs/api-reference/common/Result/interfaces/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](https://evolu.dev/docs/api-reference/common/Result/interfaces/Ok) values in an output collection.

### Example

```ts
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<
  typeof values,
  Result<
    readonly [number, string],
    CountUnavailableError | LabelUnavailableError
  >
>();
assertOk(values, [2, "books"]);
```

## Call Signature

```ts
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:1017](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1017)

Returns an object with the same keys.

### Example

```ts
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<
  typeof valuesByName,
  Result<{ readonly a: number; readonly b: number }>
>();
assertOk(valuesByName, { a: 1, b: 2 });
```

## Call Signature

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

Defined in: [packages/common/src/Result.ts:1044](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1044)

For dynamic or generated result lists.

### Example

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

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

## Call Signature

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

Defined in: [packages/common/src/Result.ts:1069](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1069)

Preserves a non-empty array on success.

### Example

```ts
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<typeof numbers, Result<NonEmptyReadonlyArray<number>>>();
assertOk(numbers, [1, 2]);
```

## Call Signature

```ts
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:1092](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1092)

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

### Example

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

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

## Call Signature

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

Defined in: [packages/common/src/Result.ts:1120](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1120)

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

```ts
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<typeof result, Result<void>>();
assertOk(result, undefined);
```

## Call Signature

```ts
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:1150](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1150)

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

### Example

```ts
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<typeof doubled, Result<NonEmptyReadonlyArray<number>>>();
assertOk(doubled, [2, 4]);

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

## Call Signature

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

Defined in: [packages/common/src/Result.ts:1178](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1178)

Maps a dynamic or generated value collection to Results.

### Example

```ts
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<typeof doubled, Result<ReadonlyArray<number>>>();
assertOk(doubled, [2, 4]);
```

## Call Signature

```ts
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:1215](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1215)

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

### Example

```ts
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<
  typeof usersByRole,
  Result<Readonly<Record<"owner" | "reviewer", User>>>
>();
assertOk(usersByRole, {
  owner: { id: "user-1" },
  reviewer: { id: "user-2" },
});
```

## Call Signature

```ts
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:1254](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1254)

Maps values to Results without collecting their Ok values.

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

### Example

```ts
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<typeof result, Result<void>>();
assertOk(result, undefined);
assertEqual(visited, [1, 2]);
```

## Call Signature

```ts
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:1281](https://github.com/evoluhq/evolu/blob/dd96d79f1dbe9a49fa12ce8e0aa7d3d0177795ca/packages/common/src/Result.ts#L1281)

Maps record values to Results without collecting their Ok values.

### Example

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

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