Interface PendingResult<T, E>

Interface defining an asynchronous Result that wraps a Promise resolving to a Result.

Extends Result functionality for pending states, with methods mirroring their synchronous counterparts but returning PendingResult or Promise for async operations. Rejections typically resolve to Err unless otherwise specified.

interface PendingResult<T, E> {
 and(
 x: Result<U, E> | Promise<Result<U, E>>,
 ): PendingResult<Awaited, Awaited<E>>;
 andThen(
 f: (x: T) => Result<U, E> | Promise<Result<U, E>>,
 ): PendingResult<Awaited, Awaited<E>>;
 catch<R = never>(
 onrejected?: (reason: unknown) => R | PromiseLike<R>,
 ): Promise<Result<T, E> | R>;
 check(): Promise<readonly [boolean, Awaited<T> | CheckedError<Awaited<E>>]>;
 err(): PendingOption<Awaited<E>>;
 flatten<U, F>(
 this:
 | PendingResult<Result<U, F>, F>
 | PendingResult<PendingResult<U, F>, F>
 | PendingResult<PromiseLike<Result<U, F>>, F>,
 ): PendingResult<Awaited, Awaited<F>>;
 inspect(f: (x: T) => unknown): PendingResult<T, E>;
 inspectErr(f: (x: CheckedError<E>) => unknown): PendingResult<T, E>;
 iter(): AsyncIterableIterator<Awaited<T>, Awaited<T>, void>;
 map(f: (x: T) => U): PendingResult<Awaited, Awaited<E>>;
 mapAll<U, F>(
 f: (x: Result<T, E>) => Result<U, F> | Promise<Result<U, F>>,
 ): PendingResult<Awaited, Awaited<F>>;
 mapErr<F>(f: (x: E) => F): PendingResult<Awaited<T>, Awaited<F>>;
 match<U, F = U>(
 f: (x: T) => U,
 g: (e: CheckedError<E>) => F,
 ): Promise<Awaited | Awaited<F>>;
 or<F>(
 x: Result<T, F> | Promise<Result<T, F>>,
 ): PendingResult<Awaited<T>, Awaited<F>>;
 orElse<F>(
 f: () => Result<T, F> | Promise<Result<T, F>>,
 ): PendingResult<Awaited<T>, Awaited<F>>;
 tap(f: (x: Result<T, E>) => unknown): PendingResult<T, E>;
 then<TResult1 = Result<T, E>, TResult2 = never>(
 onfulfilled?:
 | null
 | ((value: Result) => TResult1 | PromiseLike<TResult1>),
 onrejected?: null | ((reason: any) => TResult2 | PromiseLike<TResult2>),
 ): PromiseLike<TResult1 | TResult2>;
 transpose<U, F>(
 this: PendingResult<Option, F>,
 ): PendingOption<Result<U, F>>;
 try(): Promise<
 readonly [
 boolean,
 undefined
 | CheckedError<Awaited<E>>,
 undefined | Awaited<T>,
 ],
 >;
}

Type Parameters

Hierarchy (View Summary)

PromiseLike<Result<T, E>>
Recoverable<Result<T, E>>
- PendingResult

Index

Methods

and andThen catch check err flatten inspect inspectErr iter map mapAll mapErr match or orElse tap then transpose try

Methods

and

and(
x: Result<U, E> | Promise<Result<U, E>>,
): PendingResult<Awaited, Awaited<E>>
Returns a PendingResult that resolves to Err if this result resolves to Err, otherwise returns a PendingResult with x.

This is the asynchronous version of and.

Example
```
const x = ok<number, string>(1).toPending();
const y = ok<number, string>(2);
const z = err<number, string>("failure").toPending();

expect(await x.and(y)).toStrictEqual(ok(2));
expect(await x.and(z)).toStrictEqual(err("failure"));
expect(await z.and(x)).toStrictEqual(err("failure"));
```
Type Parameters
- U
Parameters
- x: Result<U, E> | Promise<Result<U, E>>
Returns PendingResult<Awaited, Awaited<E>>
- Defined in packages/std/src/result/interface.ts:887

andThen

andThen(
f: (x: T) => Result<U, E> | Promise<Result<U, E>>,
): PendingResult<Awaited, Awaited<E>>
Returns a PendingResult that resolves to Err if this result resolves to Err, otherwise applies f to the resolved Ok value and returns its result.

This is the asynchronous version of andThen.

Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.andThen(n => ok(n * 2))).toStrictEqual(ok(4));
expect(await x.andThen(_ => err("oops"))).toStrictEqual(err("oops"));
expect(await y.andThen(n => err("oops"))).toStrictEqual(err("failure"));
```
Type Parameters
- U
Parameters
- f: (x: T) => Result<U, E> | Promise<Result<U, E>>
Returns PendingResult<Awaited, Awaited<E>>
- Defined in packages/std/src/result/interface.ts:908

catch

catch<R = never>(
onrejected?: (reason: unknown) => R | PromiseLike<R>,
): Promise<Result<T, E> | R>
Type Parameters
- R = never
Parameters
- Optionalonrejected: (reason: unknown) => R | PromiseLike<R>
Returns Promise<Result<T, E> | R>
Inherited from Recoverable.catch
- Defined in packages/std/src/types.ts:133

check

check(): Promise<readonly [boolean, Awaited<T> | CheckedError<Awaited<E>>]>
Inspects this PendingResult’s state, returning a promise of a tuple with a success flag and either the value or error.

This is the asynchronous version of check.

Notes
- Resolves to [true, Awaited<T>] if this is an Ok, or to [false, CheckedError<Awaited<E>>] if this is an Err.
- Never rejects, providing a safe way to await the result’s state.
Example
```
const x = ok<number, string>(42).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.check()).toEqual([true, 42]);
expect(await y.check()).toEqual([false, expect.objectContaining({ expected: "failure" })]);
```
Returns Promise<readonly [boolean, Awaited<T> | CheckedError<Awaited<E>>]>
- Defined in packages/std/src/result/interface.ts:932

err

err(): PendingOption<Awaited<E>>
Converts this PendingResult to a PendingOption<E> containing the awaited error, if present.

Returns a PendingOption that resolves to Some with the error value if this resolves to an Err with ExpectedError, or to None if this resolves to an Ok or Err with UnexpectedError.

This is the asynchronous version of err.

Example
```
const x = ok<number, string>(1).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.err()).toStrictEqual(none());
expect(await y.err()).toStrictEqual(some("failure"));
```
Returns PendingOption<Awaited<E>>
- Defined in packages/std/src/result/interface.ts:954

flatten

flatten<U, F>(
 this:
 | PendingResult<Result<U, F>, F>
 | PendingResult<PendingResult<U, F>, F>
 | PendingResult<PromiseLike<Result<U, F>>, F>,
): PendingResult<Awaited, Awaited<F>>
Flattens a nested PendingResult into a single pending result, resolving any inner Result or PendingResult to its final state.

This is the asynchronous version of flatten.

Notes
- Handles cases like PendingResult<Result<T, E>, E> or PendingResult<PendingResult<T, E>, E>, resolving to PendingResult<Awaited<T>, Awaited<E>>.
Example
```
const x = ok(ok(6)).toPending();
const y = ok(err<number, string>("oops")).toPending();
const z = err<string, string>("outer").toPending();

expect(await x.flatten()).toStrictEqual(ok(6));
expect(await y.flatten()).toStrictEqual(err("oops"));
expect(await z.flatten()).toStrictEqual(err("outer"));
```
Type Parameters
- U
- F
Parameters
- this:
 | PendingResult<Result<U, F>, F>
 | PendingResult<PendingResult<U, F>, F>
 | PendingResult<PromiseLike<Result<U, F>>, F>
Returns PendingResult<Awaited, Awaited<F>>
- Defined in packages/std/src/result/interface.ts:978

inspect

inspect(f: (x: T) => unknown): PendingResult<T, E>
Calls f with the value if this pending result resolves to an Ok, then returns a new pending result with the original state.

This is the asynchronous version of inspect.

Notes
- Returns a new PendingResult instance, not the original reference.
- If f throws or returns a Promise that rejects, the error is ignored, and the returned promise still resolves to the original state.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();
let sideEffect = 0;

expect(await x.inspect(n => (sideEffect = n))).toStrictEqual(ok(2));
expect(await x.inspect(_ => { throw new Error() })).toStrictEqual(ok(2));
expect(sideEffect).toBe(2);
expect(await y.inspect(n => (sideEffect = n))).toStrictEqual(err("failure"));
expect(sideEffect).toBe(2); // Unchanged
```
Parameters
- f: (x: T) => unknown
Returns PendingResult<T, E>
- Defined in packages/std/src/result/interface.ts:1009

inspectErr

inspectErr(f: (x: CheckedError<E>) => unknown): PendingResult<T, E>
Calls f with the error if this pending result resolves to an Err, then returns a new pending result with the original state.

This is the asynchronous version of inspectErr.

Notes
- Returns a new PendingResult instance, not the original reference.
- If f throws or returns a Promise that rejects, the error is ignored, and the returned promise still resolves to the original state.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();
let sideEffect = 0;

expect(await x.inspectErr(n => (sideEffect = n))).toStrictEqual(ok(2));
expect(await x.inspectErr(_ => { throw new Error() })).toStrictEqual(ok(2));
expect(sideEffect).toBe(0);
expect(await y.inspectErr(n => (sideEffect = n))).toStrictEqual(err("failure"));
expect(await y.inspectErr(_ => { throw new Error() })).toStrictEqual(err("failure"));
expect(sideEffect).toBe(2);
```
Parameters
- f: (x: CheckedError<E>) => unknown
Returns PendingResult<T, E>
- Defined in packages/std/src/result/interface.ts:1036

iter

iter(): AsyncIterableIterator<Awaited<T>, Awaited<T>, void>

Returns an async iterator over this pending result’s value, yielding it if it resolves to Ok or nothing if it resolves to Err.

Notes

Yields exactly one item for a resolved Ok, or zero items for a resolved Err.
Compatible with for await...of loops and async spread operators (with caution).
Ignores the error value in Err cases, focusing only on the success case.

Example

const x = ok<number, string>(42).toPending();
const y = err<number, string>("failure").toPending();

const iterX = x.iter();
expect(await iterX.next()).toEqual({ value: 42, done: false });
expect(await iterX.next()).toEqual({ done: true });

const iterY = y.iter();
expect(await iterY.next()).toEqual({ done: true });

async function collect(iter) {
  const result = [];
  for await (const val of iter) result.push(val);
  return result;
}
expect(await collect(x.iter())).toEqual([42]);
expect(await collect(y.iter())).toEqual([]);

Returns AsyncIterableIterator<Awaited<T>, Awaited<T>, void>

map

map(f: (x: T) => U): PendingResult<Awaited, Awaited<E>>
Maps the resolved value with f, returning a PendingResult with the result if Ok, or the original Err if Err.

This is the asynchronous version of map.

Notes
- If f throws or returns a rejected promise, returns a PendingResult with an Err containing an UnexpectedError.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.map(n => n * 2)).toStrictEqual(ok(4));
expect(await x.map(() => { throw new Error("boom") }).unwrapErr().unexpected).toBeDefined();
expect(await y.map(n => n * 2)).toStrictEqual(err("failure"));
```
Type Parameters
- U
Parameters
- f: (x: T) => U
Returns PendingResult<Awaited, Awaited<E>>
- Defined in packages/std/src/result/interface.ts:1091

mapAll

mapAll<U, F>(
f: (x: Result<T, E>) => Result<U, F> | Promise<Result<U, F>>,
): PendingResult<Awaited, Awaited<F>>
Maps this pending result by applying a callback to its full state, executing the callback for both Ok and Err, returning a new PendingResult.

Unlike andThen, which only invokes the callback for Ok, this method always calls f, passing the entire Result as its argument.

This is the asynchronous version of mapAll.

Notes
- If f throws or returns a Promise that rejects, the newly created PendingResult will resolve to an Err with an UnexpectedError.
Example
```
const okRes = ok<number, string>(42).toPending();
const errRes = err<number, string>("failure").toPending();

const okMapped = okRes.mapAll(res => Promise.resolve(ok(res.unwrapOr(0) + 1)));
expect(await okMapped).toStrictEqual(ok(43));

const errMapped = errRes.mapAll(res => Promise.resolve(ok(res.unwrapOr(0) + 1)));
expect(await errMapped).toStrictEqual(ok(1));

const throwMapped = okRes.mapAll(() => { throw new Error("boom") });
expect(await throwMapped.unwrapErr().unexpected).toBeDefined();
```
Type Parameters
- U
- F
Parameters
- f: (x: Result<T, E>) => Result<U, F> | Promise<Result<U, F>>
Returns PendingResult<Awaited, Awaited<F>>
- Defined in packages/std/src/result/interface.ts:1123

mapErr

mapErr<F>(f: (x: E) => F): PendingResult<Awaited<T>, Awaited<F>>
Transforms this pending result by applying f to the error if it resolves to an Err with an expected error, or preserves the Ok unchanged.

This is the asynchronous version of mapErr.

Notes
- If f throws or returns a rejected promise, returns a PendingResult with an Err containing an UnexpectedError.
- If this resolves to an Err with an UnexpectedError, f is not called, and the original error is preserved.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.mapErr(e => e.length)).toStrictEqual(ok(2));
expect(await y.mapErr(e => e.length)).toStrictEqual(err(7));
expect(await y.mapErr(() => { throw new Error("boom") }).unwrapErr().unexpected).toBeDefined();
```
Type Parameters
- F
Parameters
- f: (x: E) => F
Returns PendingResult<Awaited<T>, Awaited<F>>
- Defined in packages/std/src/result/interface.ts:1149

match

match<U, F = U>(
f: (x: T) => U,
g: (e: CheckedError<E>) => F,
): Promise<Awaited | Awaited<F>>
Matches this PendingResult, returning a promise of f applied to the value if it resolves to an Ok, or g applied to the error if it resolves to an Err.

This is the asynchronous version of match.

Rejects
- With ResultError if f or g throws an exception or rejects, original error will be set as OptionError.reason.
Notes
- If f or g throws or returns a rejected Promise, the returned promise rejects with the original error. In this case the caller is responsible for handling the rejection.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.match(n => n * 2, () => 0)).toBe(4);
expect(await y.match(n => n * 2, e => e.expected.length)).toBe(7);
```
Type Parameters
- U
- F = U
Parameters
- f: (x: T) => U
- g: (e: CheckedError<E>) => F
Returns Promise<Awaited | Awaited<F>>
- Defined in packages/std/src/result/interface.ts:1176

or

or<F>(
x: Result<T, F> | Promise<Result<T, F>>,
): PendingResult<Awaited<T>, Awaited<F>>
Returns this pending result if it resolves to an Ok, otherwise returns x.

This is the asynchronous version of or.

Notes
- If this result resolves to an Err and x is a Promise that rejects, the resulting PendingResult resolves to an Err with an UnexpectedError.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.or(ok(3))).toStrictEqual(ok(2));
expect(await x.or(err("another one"))).toStrictEqual(ok(2));
expect(await y.or(ok(3))).toStrictEqual(ok(3));
expect(await y.or(err("another one"))).toStrictEqual(err("failure"));
expect(await y.or(Promise.reject(new Error("boom"))).unwrapErr().unexpected).toBeDefined();
```
Type Parameters
- F
Parameters
- x: Result<T, F> | Promise<Result<T, F>>
Returns PendingResult<Awaited<T>, Awaited<F>>
- Defined in packages/std/src/result/interface.ts:1204

orElse

orElse<F>(
f: () => Result<T, F> | Promise<Result<T, F>>,
): PendingResult<Awaited<T>, Awaited<F>>
Returns this PendingResult if it resolves to Ok, otherwise returns a PendingResult with the result of f.

This is the asynchronous version of orElse.

Notes
- If f throws or returns a rejected promise, the resulting PendingResult resolves to an Err with an UnexpectedError.
Example
```
const x = ok<number, string>(2).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.orElse(() => ok(3))).toStrictEqual(ok(2));
expect(await y.orElse(() => Promise.resolve(ok(3)))).toStrictEqual(ok(3));
expect(await y.orElse(() => { throw new Error("boom") }).unwrapErr().unexpected).toBeDefined();
expect(await y.orElse(() => err("another one"))).toStrictEqual(err("another one"));
```
Type Parameters
- F
Parameters
- f: () => Result<T, F> | Promise<Result<T, F>>
Returns PendingResult<Awaited<T>, Awaited<F>>
- Defined in packages/std/src/result/interface.ts:1230

tap

tap(f: (x: Result<T, E>) => unknown): PendingResult<T, E>
Executes f with the resolved result, then returns a new PendingResult unchanged.

This is the asynchronous version of tap.

Notes
- If f throws or rejects, the error is ignored
- If f returns a promise, the promise is not awaited before returning
Example
```
const x = pendingResult(ok<number, string>(42));
const y = pendingResult(err<number, string>("failure"));
let log = "";

expect(await x.tap(res => (log = res.toString()))).toStrictEqual(ok(42));
expect(log).toBe("Ok { 42 }");
expect(await y.tap(res => (log = res.toString()))).toStrictEqual(err("failure"));
expect(log).toBe("Err { 'failure' }");
```
Parameters
- f: (x: Result<T, E>) => unknown
Returns PendingResult<T, E>
- Defined in packages/std/src/result/interface.ts:1256

then

then<TResult1 = Result<T, E>, TResult2 = never>(
 onfulfilled?:
 | null
 | ((value: Result) => TResult1 | PromiseLike<TResult1>),
 onrejected?: null | ((reason: any) => TResult2 | PromiseLike<TResult2>),
): PromiseLike<TResult1 | TResult2>
Attaches callbacks for the resolution and/or rejection of the Promise.
Type Parameters
- TResult1 = Result<T, E>
- TResult2 = never
Parameters
- Optionalonfulfilled: null | ((value: Result) => TResult1 | PromiseLike<TResult1>)
 The callback to execute when the Promise is resolved.
- Optionalonrejected: null | ((reason: any) => TResult2 | PromiseLike<TResult2>)
 The callback to execute when the Promise is rejected.
Returns PromiseLike<TResult1 | TResult2>
A Promise for the completion of which ever callback is executed.
Inherited from PromiseLike.then
- Defined in node_modules/.pnpm/typescript@5.7.3/node_modules/typescript/lib/lib.es5.d.ts:1537

transpose

transpose<U, F>(this: PendingResult<Option, F>): PendingOption<Result<U, F>>
Transposes a PendingResult of an Option into a PendingOption containing a Result.

This is the asynchronous version of transpose.

Example
```
const x = pendingOption(some(ok(2)));
const y = pendingOption(some(err("error")));
const z = pendingOption(none<Result<number, string>>());

expect(await x.transpose()).toStrictEqual(ok(some(2)));
expect(await y.transpose()).toStrictEqual(err("error"));
expect(await z.transpose()).toStrictEqual(ok(none()));
```
Type Parameters
- U
- F
Parameters
- this: PendingResult<Option, F>
Returns PendingOption<Result<U, F>>
- Defined in packages/std/src/result/interface.ts:1275

try

try(): Promise<
 readonly [
 boolean,
 undefined
 | CheckedError<Awaited<E>>,
 undefined | Awaited<T>,
 ],
>
Extracts this PendingResult’s state, returning a promise of a tuple with a success flag, error, and value.

Inspired by the Try Operator proposal.

This is the asynchronous version of try.

Notes
- Resolves to [true, undefined, Awaited<T>] if this is an Ok, or [false, CheckedError<Awaited<E>>, undefined] if this is an Err.
- Never rejects, offering a safe way to await the result’s state with explicit success indication.
Example
```
const x = ok<number, string>(42).toPending();
const y = err<number, string>("failure").toPending();

expect(await x.try()).toEqual([true, undefined, 42]);
expect(await y.try()).toEqual([false, expect.objectContaining({ expected: "failure" }), undefined]);
```
Returns Promise<
 readonly [
 boolean,
 undefined
 | CheckedError<Awaited<E>>,
 undefined | Awaited<T>,
 ],
>
- Defined in packages/std/src/result/interface.ts:1303

Interface PendingResult<T, E>

Type Parameters

Hierarchy (View Summary)

Index

Methods

Methods

and

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<U>, Awaited<E>>

andThen

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<U>, Awaited<E>>

catch

Type Parameters

Parameters

Returns Promise<Result<T, E> | R>

check

Notes

Example

Returns Promise<readonly [boolean, Awaited<T> | CheckedError<Awaited<E>>]>

err

Example

Returns PendingOption<Awaited<E>>

flatten

Notes

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<U>, Awaited<F>>

inspect

Notes

Example

Parameters

Returns PendingResult<T, E>

inspectErr

Notes

Example

Parameters

Returns PendingResult<T, E>

iter

Notes

Example

Returns AsyncIterableIterator<Awaited<T>, Awaited<T>, void>

map

Notes

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<U>, Awaited<E>>

mapAll

Notes

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<U>, Awaited<F>>

mapErr

Notes

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<T>, Awaited<F>>

match

Rejects

Notes

Example

Type Parameters

Parameters

Returns Promise<Awaited<U> | Awaited<F>>

or

Notes

Example

Type Parameters

Parameters

Returns PendingResult<Awaited<T>, Awaited<F>>

orElse

Notes

Returns Promise<
readonly [
boolean,
undefined
| CheckedError<Awaited<E>>,
undefined | Awaited<T>,
],
>