Interface Resultant<T, E>

Interface representing the resultant state of an operation, either a success (Ok<T>) or an error (Err<E>).

Inspired by Rust’s Result, it provides a type-safe alternative to exceptions for handling success or failure outcomes.

interface Resultant<T, E> {
 and(x: Result<U, E>): Result<U, E>;
 andThen(f: (x: T) => Result<U, E>): Result<U, E>;
 check(this: SettledResult<T, E>): readonly [false, CheckedError<E>];
 clone<U, F>(this: Result<Cloneable, Cloneable<F>>): Result<U, F>;
 copy(): Result<T, E>;
 err(this: SettledResult<T, E>): Option<E>;
 expect(this: SettledResult<T, E>, msg?: string): T;
 expectErr(this: SettledResult<T, E>, msg?: string): CheckedError<E>;
 flatten<U, F>(this: Result<Result<U, F>, F>): Result<U, F>;
 inspect(f: (x: T) => unknown): Result<T, E>;
 inspectErr(f: (x: CheckedError<E>) => unknown): Result<T, E>;
 isErr(): this is Err<T, E>;
 isErrAnd(
 f: (x: CheckedError<E>) => boolean,
 ): this is Resultant<T, E> & { error: CheckedError<E> } & boolean;
 isOk(): this is Ok<T, E>;
 isOkAnd(
 f: (x: T) => boolean,
 ): this is Resultant<T, E> & { value: T } & boolean;
 iter(): IterableIterator<T, T, void>;
 map(f: (x: T) => Awaited): Result<U, E>;
 mapAll<U, F>(f: (x: Result<T, E>) => Result<U, F>): Result<U, F>;
 mapAll<U, F>(
 f: (x: Result<T, E>) => Promise<Result<U, F>>,
 ): PendingResult<Awaited, Awaited<F>>;
 mapErr<F>(f: (e: E) => Awaited<F>): Result<T, F>;
 mapOr(
 this: SettledResult<T, E>,
 def: Awaited,
 f: (x: T) => Awaited,
 ): U;
 mapOrElse(
 this: SettledResult<T, E>,
 mkDef: () => Awaited,
 f: (x: T) => Awaited,
 ): U;
 match<U, F = U>(
 this: SettledResult<T, E>,
 f: (x: T) => Awaited,
 g: (e: CheckedError<E>) => Awaited<F>,
 ): U | F;
 ok(): Option<T>;
 or<F>(x: Result<T, F>): Result<T, F>;
 orElse<F>(f: () => Result<T, F>): Result<T, F>;
 tap(f: (x: Result<T, E>) => unknown): Result<T, E>;
 toPending(): PendingResult<Awaited<T>, Awaited<E>>;
 toPendingCloned(
 this: Result<Cloneable<T>, Cloneable<E>>,
 ): PendingResult<Awaited<T>, Awaited<E>>;
 toString(): string;
 transpose<U, F>(this: Result<Option, F>): Option<Result<U, F>>;
 try(
 this: SettledResult<T, E>,
 ): readonly [false, CheckedError<E>, undefined];
 unwrap(this: SettledResult<T, E>): T;
 unwrapErr(this: SettledResult<T, E>): CheckedError<E>;
 unwrapOr(this: SettledResult<T, E>, def: Awaited<T>): T;
 unwrapOrElse(this: SettledResult<T, E>, mkDef: () => Awaited<T>): T;
}

Type Parameters

Methods

and

and(x: Result<U, E>): Result<U, E>

Returns x if this result is Ok, otherwise returns the Err value of self.

Example

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

expect(x.and(y)).toStrictEqual(ok(2));
expect(x.and(z)).toStrictEqual(err("failure"));
expect(z.and(x)).toStrictEqual(err("failure"));

Type Parameters

Parameters

x: Result<U, E>

Returns Result<U, E>

andThen

andThen(f: (x: T) => Result<U, E>): Result<U, E>
Applies f to the value if this result is Ok and returns its result, otherwise returns the Err value of self.

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

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

check

check(this: SettledResult<T, E>): readonly [false, CheckedError<E>]
Inspects this result’s state, returning a tuple indicating success and either the value or error.

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

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

clone

clone<U, F>(this: Result<Cloneable, Cloneable<F>>): Result<U, F>
Returns a deep copy of the Result.

Only available on Results with Cloneable value and error.

Example
```
const x = ok(1);
const y = ok({ a: 1, clone: () => ({ a: 0 }) });

expect(x.clone()).toStrictEqual(ok(1));
expect(x.clone()).not.toBe(x); // Different reference
expect(x.clone().unwrap()).toBe(1);
expect(y.clone()).toStrictEqual(ok({ a: 0 }));
```
Type Parameters
- U
- F
Parameters
- this: Result<Cloneable, Cloneable<F>>
Returns Result<U, F>
- Defined in packages/std/src/result/interface.ts:186

copy

copy(): Result<T, E>

Returns a shallow copy of the Result.

Example

const value = { a: 1 };
const x = ok<{ a: number }, string>(value);

expect(x.copy()).toStrictEqual(ok({ a: 1 }));
expect(x.copy()).not.toBe(x); // Different result reference
expect(x.copy().unwrap()).toBe(value); // Same value reference

Returns Result<T, E>

err

err(this: SettledResult<T, E>): Option<E>
Converts this Result to an Option<E> containing the error, if present.

Returns Some with the error value if this is an Err, or None if this is an Ok.

Notes
- Extracts the error from CheckedError if it’s an ExpectedError; returns None for UnexpectedError.
Example
```
const x = ok<number, string>(1);
const y = err<number, string>("failure");

expect(x.err()).toStrictEqual(none());
expect(y.err()).toStrictEqual(some("failure"));
```
Parameters
- this: SettledResult<T, E>
Returns Option<E>
- Defined in packages/std/src/result/interface.ts:223

expect

expect(this: SettledResult<T, E>, msg?: string): T
Retrieves the value if this result is an Ok, or throws a ResultError with an optional message if it’s an Err.

Throws
- ResultError if this result is an Err
Example
```
const x = ok<number, string>(42);
const y = err<number, string>("failure");

expect(x.expect("Failed!")).toBe(42);
expect(() => y.expect("Failed!")).toThrow(ResultError);
```
Parameters
- this: SettledResult<T, E>
- Optionalmsg: string
Returns T
- Defined in packages/std/src/result/interface.ts:241

expectErr

expectErr(this: SettledResult<T, E>, msg?: string): CheckedError<E>
Retrieves the error if this result is an Err, or throws a ResultError with an optional message if it’s an Ok.

Throws
- ResultError if this result is an Ok
Example
```
const x = ok<number, string>(42);
const y = err<number, string>("failure");

expect(() => x.expectErr("Failed!")).toThrow(ResultError);
expect(isCheckedError(y.expectErr("Failed!"))).toBe(true);
expect(y.expectErr("Failed!").expected).toBe("failure");
```
Parameters
- this: SettledResult<T, E>
- Optionalmsg: string
Returns CheckedError<E>
- Defined in packages/std/src/result/interface.ts:260

flatten

flatten<U, F>(this: Result<Result<U, F>, F>): Result<U, F>

Flattens a nested result (Result<Result<T, E>, E>) into a single result (Result<T, E>).

Example

const x: Result<Result<Result<number, string>, string>, string> = ok(ok(ok(6)));
const y: Result<Result<number, string>, string> = x.flatten();
const z: Result<Result<number, string>, string> = err("oops");

expect(x.flatten()).toStrictEqual(ok(ok(6)));
expect(y.flatten()).toStrictEqual(ok(6));
expect(z.flatten().expected).toBe("oops");

Type Parameters

Parameters

this: Result<Result<U, F>, F>

Returns Result<U, F>

inspect

inspect(f: (x: T) => unknown): Result<T, E>

Calls f with the value if this result is an Ok, then returns a copy of this result.

Notes

Returns a new Result instance, not the original reference.
If f throws or returns a Promise that rejects, the error is ignored.

Example

const x = ok<number, string>(2);
const y = err<number, string>("failure");
let sideEffect = 0;

expect(x.inspect(n => (sideEffect = n))).toStrictEqual(ok(2));
expect(x.inspect(_ => { throw new Error() })).toStrictEqual(ok(2));
expect(sideEffect).toBe(2);
expect(y.inspect(n => (sideEffect = n))).toStrictEqual(err("failure"));
expect(sideEffect).toBe(2); // Unchanged

Parameters

f: (x: T) => unknown

Returns Result<T, E>

inspectErr

inspectErr(f: (x: CheckedError<E>) => unknown): Result<T, E>

Calls f with the value if this result is an Err, then returns a copy of this result.

Notes

Returns a new Result instance, not the original reference.
If f throws or returns a Promise that rejects, the error is ignored.

Example

const x = ok<number, string>(2);
const y = err<number, string>("failure");
let sideEffect = 0;

expect(x.inspect(n => (sideEffect = n))).toStrictEqual(ok(2));
expect(x.inspect(_ => { throw new Error() })).toStrictEqual(ok(2));
expect(sideEffect).toBe(0);
expect(y.inspect(n => (sideEffect = n))).toStrictEqual(err("failure"));
expect(y.inspect(_ => { throw new Error() })).toStrictEqual(err("failure"));
expect(sideEffect).toBe(2);

Parameters

f: (x: CheckedError<E>) => unknown

Returns Result<T, E>

isErr

isErr(): this is Err<T, E>
Checks if this result is an Err, narrowing its type to Err if true.

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

expect(x.isErr()).toBe(false);
expect(y.isErr()).toBe(true);
```
Returns this is Err<T, E>
- Defined in packages/std/src/result/interface.ts:339

isErrAnd

isErrAnd(
f: (x: CheckedError<E>) => boolean,
): this is Resultant<T, E> & { error: CheckedError<E> } & boolean
Returns true if the result is Err and f returns true for the contained error.

Notes
- Default: If f throws, false is returned.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

expect(x.isErrAnd(e => e.expected === "failure")).toBe(false);
expect(y.isErrAnd(e => e.expected === "failure")).toBe(true);
expect(y.isErrAnd(e => Boolean(e.unexpected))).toBe(false);
```
Parameters
- f: (x: CheckedError<E>) => boolean
Returns this is Resultant<T, E> & { error: CheckedError<E> } & boolean
- Defined in packages/std/src/result/interface.ts:358

isOk

isOk(): this is Ok<T, E>
Checks if this result is an Ok, narrowing its type to Ok if true.

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

expect(x.isOk()).toBe(true);
expect(y.isOk()).toBe(false);
```
Returns this is Ok<T, E>
- Defined in packages/std/src/result/interface.ts:373

isOkAnd

isOkAnd(f: (x: T) => boolean): this is Resultant<T, E> & { value: T } & boolean
Returns true if the result is Ok and f returns true for the contained value.

Notes
- Default: If f throws, false is returned.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

expect(x.isOkAnd(n => n > 0)).toBe(true);
expect(x.isOkAnd(n => n < 0)).toBe(false);
expect(y.isOkAnd(n => true)).toBe(false);
```
Parameters
- f: (x: T) => boolean
Returns this is Resultant<T, E> & { value: T } & boolean
- Defined in packages/std/src/result/interface.ts:392

iter

iter(): IterableIterator<T, T, void>
Returns an iterator over this result’s value, yielding it if Ok or nothing if Err.

Notes
- Yields exactly one item for Ok, or zero items for Err.
- Compatible with for...of loops and spread operators.
- Ignores the error value in Err cases, focusing only on the success case.
Example
```
const x = ok<number, string>(42);
const y = err<number, string>("failure");

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

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

expect([...x.iter()]).toEqual([42]);
expect([...y.iter()]).toEqual([]);
```
Returns IterableIterator<T, T, void>
- Defined in packages/std/src/result/interface.ts:419

map

map(f: (x: T) => Awaited): Result<U, E>
Transforms this result by applying f to the value if it’s an Ok, or preserves the Err unchanged.

Notes
- If f throws, returns an Err with an UnexpectedError containing the original error.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

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

mapAll

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

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

Notes
- If f throws an Err with an UnexpectedError is returned.
Example
```
const okRes = ok<number, string>(42);
const errRes = err<number, string>("failure");

expect(okRes.mapAll(res => ok(res.unwrapOr(0) + 1))).toStrictEqual(ok(43));
expect(errRes.mapAll(res => ok(res.unwrapOr(0) + 1))).toStrictEqual(ok(1));
expect(okRes.mapAll(res => res.isOk() ? ok("success") : err("fail"))).toStrictEqual(ok("success"));
expect(errRes.mapAll(() => { throw new Error("boom") }).unwrapErr().unexpected).toBeDefined();
```
Type Parameters
- U
- F
Parameters
- f: (x: Result<T, E>) => Result<U, F>
Returns Result<U, F>
- Defined in packages/std/src/result/interface.ts:463

mapAll<U, F>(
f: (x: Result<T, E>) => Promise<Result<U, F>>,
): PendingResult<Awaited, Awaited<F>>

Maps this 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.

Notes

If f returns a Promise that rejects, the resulting PendingResult resolves to an Err with an UnexpectedError.

Example

const okRes = ok<number, string>(42);
const errRes = err<number, string>("failure");

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

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

const mappedCheck = okRes.mapAll(res => Promise.resolve(res.isOk() ? ok("success") : err("fail")));
expect(await mappedCheck).toStrictEqual(ok("success"));

const mappedThrow = errRes.mapAll(() => Promise.reject(new Error("boom")));
expect((await mappedThrow).unwrapErr().unexpected).toBeDefined();

Type Parameters

Parameters

f: (x: Result<T, E>) => Promise<Result<U, F>>

Returns PendingResult<Awaited, Awaited<F>>

mapErr

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

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

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

mapOr

mapOr(this: SettledResult<T, E>, def: Awaited, f: (x: T) => Awaited): U
Returns f applied to the value if Ok, otherwise returns def.

Notes
- Default: If f throws, returns def.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

expect(x.mapOr(0, n => n * 2)).toBe(4);
expect(x.mapOr(0, () => { throw new Error("boom") }).unwrapErr().unexpected).toBeDefined();
expect(y.mapOr(0, n => n * 2)).toBe(0);
```
Type Parameters
- U
Parameters
- this: SettledResult<T, E>
- def: Awaited
- f: (x: T) => Awaited
Returns U
- Defined in packages/std/src/result/interface.ts:537

mapOrElse

mapOrElse(
 this: SettledResult<T, E>,
 mkDef: () => Awaited,
 f: (x: T) => Awaited,
): U
Returns f applied to the contained value if Ok, otherwise returns the result of mkDef.

Throws
- ResultError if mkDef is called and throws an exception, with the original error set as ResultError.reason.
Notes
- If f throws, the error is silently ignored, and the result of mkDef is returned.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

expect(x.mapOrElse(() => 0, n => n * 2)).toBe(4);
expect(x.mapOrElse(() => 1, () => { throw new Error("boom") })).toBe(1);
expect(() => y.mapOrElse(() => { throw new Error("boom") }, n => n * 2)).toThrow(ResultError);
expect(y.mapOrElse(() => 0, n => n * 2)).toBe(0);
```
Type Parameters
- U
Parameters
- this: SettledResult<T, E>
- mkDef: () => Awaited
- f: (x: T) => Awaited
Returns U
- Defined in packages/std/src/result/interface.ts:566

match

match<U, F = U>(
 this: SettledResult<T, E>,
 f: (x: T) => Awaited,
 g: (e: CheckedError<E>) => Awaited<F>,
): U | F
Matches this result, returning f applied to the value if Ok, or g applied to the CheckedError if Err.

Throws
- ResultError if f or g throws an exception, with the original error set as ResultError.reason.
Notes
- If f or g return a Promise that rejects, the caller is responsible for handling the rejection.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

expect(x.match(n => n * 2, () => 0)).toBe(4);
expect(() => x.match(_ => { throw new Error() }, () => 0)).toThrow(ResultError);
expect(y.match(n => n * 2, e => e.expected.length)).toBe(7);
expect(() => y.match(n => n * 2, () => { throw new Error() })).toThrow(ResultError);
```
Type Parameters
- U
- F = U
Parameters
- this: SettledResult<T, E>
- f: (x: T) => Awaited
- g: (e: CheckedError<E>) => Awaited<F>
Returns U | F
- Defined in packages/std/src/result/interface.ts:595

ok

ok(): Option<T>
Converts this result to an Option, discarding the error if present.

Maps Ok(v) to Some(v) and Err(e) to None.

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

expect(x.ok()).toStrictEqual(some(2));
expect(y.ok()).toStrictEqual(none());
```
Returns Option<T>
- Defined in packages/std/src/result/interface.ts:616

or

or<F>(x: Result<T, F>): Result<T, F>

Returns the current result if it is Ok, otherwise returns x.

Example

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

expect(x.or(ok(3))).toStrictEqual(ok(2));
expect(x.or(err("failure"))).toStrictEqual(ok(2));
expect(y.or(ok(3))).toStrictEqual(ok(3));
expect(y.or(err("another one"))).toStrictEqual(err("failure"));

Type Parameters

Parameters

x: Result<T, F>

Returns Result<T, F>

orElse

orElse<F>(f: () => Result<T, F>): Result<T, F>

Returns the current result if Ok, otherwise returns the result of f.

Notes

If f throws, returns an Err with an UnexpectedError containing the original error.

Example

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

expect(x.orElse(() => ok(3))).toStrictEqual(ok(2));
expect(y.orElse(() => ok(3))).toStrictEqual(ok(3));
expect(y.orElse(() => { throw new Error("boom") }).unwrapErr().unexpected).toBeDefined();
expect(y.orElse(() => err("another one"))).toStrictEqual(err("another one"));

Type Parameters

Parameters

f: () => Result<T, F>

Returns Result<T, F>

tap

tap(f: (x: Result<T, E>) => unknown): Result<T, E>
Executes f with a copy of this result, then returns a new copy unchanged.

Useful for side-effects like logging, works with both Ok and Err.

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

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

toPending

toPending(): PendingResult<Awaited<T>, Awaited<E>>
Converts this result to a PendingResult using a shallow copy of its current state.

Notes
- Useful for transposing a result with a PromiseLike value to a PendingResult with an Awaited value.
Example
```
const value = { a: 1 };
const x = ok<{ a: number }, string>(value);
const pendingX = x.toPending();

expect(isPendingResult(pendingX)).toBe(true);
expect(await pendingX).toStrictEqual(ok({ a: 1 }));
value.a = 2;
expect(await pendingX).toStrictEqual(ok({ a: 2 }));
```
Returns PendingResult<Awaited<T>, Awaited<E>>
- Defined in packages/std/src/result/interface.ts:697

toPendingCloned

toPendingCloned(
this: Result<Cloneable<T>, Cloneable<E>>,
): PendingResult<Awaited<T>, Awaited<E>>
Converts this result to a PendingResult using a deep clone of its current state.

Notes
- Useful for transposing a result with a PromiseLike value to a PendingResult with an Awaited value, preserving independence from the original data.
Example
```
const value = { a: 1, clone: () => ({ a: 0 }) };
const x = ok(value);
const pendingX = x.toPendingCloned();

expect(isPendingResult(pendingX)).toBe(true);
expect((await pendingX).unwrap()).toStrictEqual({ a: 0 });
value.a = 42;
expect((await pendingX).unwrap()).toStrictEqual({ a: 0 });
```
Parameters
- this: Result<Cloneable<T>, Cloneable<E>>
Returns PendingResult<Awaited<T>, Awaited<E>>
- Defined in packages/std/src/result/interface.ts:720

toString

toString(): string

Generates a string representation of this result, reflecting its current state.

Example

const x = ok<number, string>(2);
const y = err<number, string>("error");

expect(x.toString()).toBe("Ok { 2 }");
expect(y.toString()).toBe("Err { 'error' }");

Returns string

transpose

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

Maps Ok(None) to None, Ok(Some(_)) to Some(Ok(_)) and Err(_) to Some(Err(_)).

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

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

try

try(this: SettledResult<T, E>): readonly [false, CheckedError<E>, undefined]
Extracts this result’s state, returning a tuple with a success flag, error, and value.

Inspired by the Try Operator proposal.

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

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

unwrap

unwrap(this: SettledResult<T, E>): T
Retrieves the value if this result is an Ok, or throws a ResultError if it’s an Err.

Throws
- ResultError if this result is an Err
Example
```
const x = ok<number, string>(42);
const y = err<number, string>("failure");

expect(x.unwrap()).toBe(42);
expect(() => y.unwrap()).toThrow(ResultError);
```
Parameters
- this: SettledResult<T, E>
Returns T
- Defined in packages/std/src/result/interface.ts:803

unwrapErr

unwrapErr(this: SettledResult<T, E>): CheckedError<E>
Retrieves the CheckedError if this result is an Err, or throws a ResultError if it’s an Ok.

Throws
- ResultError if this result is an Ok
Example
```
const x = ok<number, string>(42);
const y = err<number, string>("failure");

expect(() => x.unwrapErr()).toThrow(ResultError);
expect(y.unwrapErr().expected).toBe("failure");
```
Parameters
- this: SettledResult<T, E>
Returns CheckedError<E>
- Defined in packages/std/src/result/interface.ts:821

unwrapOr

unwrapOr(this: SettledResult<T, E>, def: Awaited<T>): T
Returns the contained value if Ok, or def if Err.

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

expect(x.unwrapOr(0)).toBe(2);
expect(y.unwrapOr(0)).toBe(0);
```
Parameters
- this: SettledResult<T, E>
- def: Awaited<T>
Returns T
- Defined in packages/std/src/result/interface.ts:835

unwrapOrElse

unwrapOrElse(this: SettledResult<T, E>, mkDef: () => Awaited<T>): T
Returns the contained value if Ok, or the result of mkDef if Err.

Throws
- ResultError if mkDef throws, with the original error set as ResultError.reason.
Example
```
const x = ok<number, string>(2);
const y = err<number, string>("failure");

expect(x.unwrapOrElse(() => 0)).toBe(2);
expect(y.unwrapOrElse(() => 0)).toBe(0);
expect(() => y.unwrapOrElse(() => { throw new Error("boom") })).toThrow(ResultError);
```
Parameters
- this: SettledResult<T, E>
- mkDef: () => Awaited<T>
Returns T
- Defined in packages/std/src/result/interface.ts:855

Interface Resultant<T, E>

Type Parameters

Index

Methods

Methods

and

Example

Type Parameters

Parameters

Returns Result<U, E>

andThen

Example

Type Parameters

Parameters

Returns Result<U, E>

check

Notes

Example

Parameters

Returns readonly [false, CheckedError<E>]

clone

Example

Type Parameters

Parameters

Returns Result<U, F>

copy

Example

Returns Result<T, E>

err

Notes

Example

Parameters

Returns Option<E>

expect

Throws

Example

Parameters

Returns T

expectErr

Throws

Example

Parameters

Returns CheckedError<E>

flatten

Example

Type Parameters

Parameters

Returns Result<U, F>

inspect

Notes

Example

Parameters

Returns Result<T, E>

inspectErr

Notes

Example

Parameters

Returns Result<T, E>

isErr

Example

Returns this is Err<T, E>

isErrAnd

Notes

Example

Parameters

Returns this is Resultant<T, E> & { error: CheckedError<E> } & boolean

isOk

Example

Returns this is Ok<T, E>

isOkAnd

Notes

Example

Parameters

Returns this is Resultant<T, E> & { value: T } & boolean

iter

Notes

Example

Returns IterableIterator<T, T, void>

map

Notes