[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:995](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L995)

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<
  Result<
    readonly [number, string],
    CountUnavailableError | LabelUnavailableError
  >,
  typeof values
>();
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:1022](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1022)

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<
  Result<{ readonly a: number; readonly b: number }>,
  typeof valuesByName
>();
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:1049](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1049)

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<Result<ReadonlyArray<number>>, typeof numbers>();
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:1074](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1074)

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<Result<NonEmptyReadonlyArray<number>>, typeof numbers>();
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:1097](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1097)

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<Result<void>, typeof result>();
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:1125](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1125)

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<Result<void>, typeof result>();
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:1155](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1155)

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<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

```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:1183](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1183)

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<Result<ReadonlyArray<number>>, typeof doubled>();
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:1220](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1220)

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<
  Result<Readonly<Record<"owner" | "reviewer", User>>>,
  typeof usersByRole
>();
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:1259](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1259)

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<Result<void>, typeof result>();
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:1286](https://github.com/evoluhq/evolu/blob/037c390af081e9944d616ff298a729515c5c5ab7/packages/common/src/Result.ts#L1286)

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