Interface Ok<T, E>

An Ok instance is the successful variant of the Result type, representing a successful outcome from an operation which may fail.

Implemented using neverthrow

interface Ok<T, E> {
    value: T;
    _unsafeUnwrap(_?: ErrorConfig): T;
    _unsafeUnwrapErr(config?: ErrorConfig): E;
    "[iterator]"(): Generator<Err<never, E>, T>;
    andTee(f: (t: T) => unknown): Result<T, E>;
    andThen<R extends Result<unknown, unknown>>(
        f: (t: T) => R,
    ): Result<InferOkTypes<R>, E | InferErrTypes<R>>;
    andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
    andThrough<R extends Result<unknown, unknown>>(
        f: (t: T) => R,
    ): Result<T, E | InferErrTypes<R>>;
    andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
    asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
    asyncAndThrough<R extends ResultAsync<unknown, unknown>>(
        f: (t: T) => R,
    ): ResultAsync<T, E | InferAsyncErrTypes<R>>;
    asyncAndThrough<F>(
        f: (t: T) => ResultAsync<unknown, F>,
    ): ResultAsync<T, E | F>;
    asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
    isErr(): this is Err<T, E>;
    isOk(): this is Ok<T, E>;
    map<A>(f: (t: T) => A): Result<A, E>;
    mapErr<U>(_f: (e: E) => U): Result<T, U>;
    match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
    orElse<R extends Result<unknown, unknown>>(
        _f: (e: E) => R,
    ): Result<T | InferOkTypes<R>, InferErrTypes<R>>;
    orElse<U, A>(_f: (e: E) => Result<U, A>): Result<T | U, A>;
    orTee(_f: (t: E) => unknown): Result<T, E>;
    safeUnwrap(): Generator<Err<never, E>, T>;
    unwrapOr<A>(_v: A): T | A;
}

Type Parameters

  • T

    The type of the value contained in the Result for the success case

  • E

    The type of the error contained in the Result for the failure case

Hierarchy

  • Ok<T, E>
    • Ok

Methods

_unsafeUnwrap _unsafeUnwrapErr [iterator] andTee andThen andThrough asyncAndThen asyncAndThrough asyncMap isErr isOk map mapErr match orElse orTee safeUnwrap unwrapOr

Properties

value

Methods

_unsafeUnwrap

  • _unsafeUnwrap(_?: ErrorConfig): T

    This method is unsafe, and should only be used in a test environments

    Takes a Result<T, E> and returns a T when the result is an Ok, otherwise it throws a custom object.

    Parameters

    • Optional_: ErrorConfig

    Returns T

_unsafeUnwrapErr

  • _unsafeUnwrapErr(config?: ErrorConfig): E

    This method is unsafe, and should only be used in a test environments

    takes a Result<T, E> and returns a E when the result is an Err, otherwise it throws a custom object.

    Parameters

    • Optionalconfig: ErrorConfig

    Returns E

[iterator]

  • "[iterator]"(): Generator<Err<never, E>, T>

    Returns Generator<Err<never, E>, T>

andTee

  • andTee(f: (t: T) => unknown): Result<T, E>

    This "tee"s the current value to an passed-in computation such as side effect functions but still returns the same current value as the result.

    This is useful when you want to pass the current result to your side-track work such as logging but want to continue main-track work after that. This method does not care about the result of the passed in computation.

    Parameters

    • f: (t: T) => unknown

      The function to apply to the current value

    Returns Result<T, E>

andThen

  • andThen<R extends Result<unknown, unknown>>(
        f: (t: T) => R,
    ): Result<InferOkTypes<R>, E | InferErrTypes<R>>

    Similar to map Except you must return a new Result.

    This is useful for when you need to do a subsequent computation using the inner T value, but that computation might fail. Additionally, andThen is really useful as a tool to flatten a Result<Result<A, E2>, E1> into a Result<A, E2> (see example below).

    Type Parameters

    • R extends Result<unknown, unknown>

    Parameters

    • f: (t: T) => R

      The function to apply to the current value

    Returns Result<InferOkTypes<R>, E | InferErrTypes<R>>

  • andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>

    Type Parameters

    • U
    • F

    Parameters

    • f: (t: T) => Result<U, F>

    Returns Result<U, E | F>

andThrough

  • andThrough<R extends Result<unknown, unknown>>(
        f: (t: T) => R,
    ): Result<T, E | InferErrTypes<R>>

    Similar to andTee except error result of the computation will be passed to the downstream in case of an error.

    This version is useful when you want to make side-effects but in case of an error, you want to pass the error to the downstream.

    Type Parameters

    • R extends Result<unknown, unknown>

    Parameters

    • f: (t: T) => R

      The function to apply to the current value

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

  • andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>

    Type Parameters

    • F

    Parameters

    • f: (t: T) => Result<unknown, F>

    Returns Result<T, E | F>

asyncAndThen

  • asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>

    Similar to map Except you must return a new Result.

    This is useful for when you need to do a subsequent async computation using the inner T value, but that computation might fail. Must return a ResultAsync

    Type Parameters

    • U
    • F

    Parameters

    • f: (t: T) => ResultAsync<U, F>

      The function that returns a ResultAsync to apply to the current value

    Returns ResultAsync<U, E | F>

asyncAndThrough

  • asyncAndThrough<R extends ResultAsync<unknown, unknown>>(
        f: (t: T) => R,
    ): ResultAsync<T, E | InferAsyncErrTypes<R>>

    Type Parameters

    • R extends ResultAsync<unknown, unknown>

    Parameters

    • f: (t: T) => R

    Returns ResultAsync<T, E | InferAsyncErrTypes<R>>

  • asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>

    Type Parameters

    • F

    Parameters

    • f: (t: T) => ResultAsync<unknown, F>

    Returns ResultAsync<T, E | F>

asyncMap

  • asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>

    Maps a Result<T, E> to ResultAsync<U, E> by applying an async function to a contained Ok value, leaving an Err value untouched.

    Type Parameters

    • U

    Parameters

    • f: (t: T) => Promise<U>

      An async function to apply an OK value

    Returns ResultAsync<U, E>

isErr

  • isErr(): this is Err<T, E>

    Used to check if a Result is an Err

    Returns this is Err<T, E>

    true if the result is an Err variant of Result

isOk

  • isOk(): this is Ok<T, E>

    Used to check if a Result is an OK

    Returns this is Ok<T, E>

    true if the result is an OK variant of Result

map

  • map<A>(f: (t: T) => A): Result<A, E>

    Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value, leaving an Err value untouched.

    Type Parameters

    • A

    Parameters

    • f: (t: T) => A

      The function to apply an OK value

    Returns Result<A, E>

    the result of applying f or an Err untouched

mapErr

  • mapErr<U>(_f: (e: E) => U): Result<T, U>

    Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value, leaving an Ok value untouched.

    This function can be used to pass through a successful result while handling an error.

    Type Parameters

    • U

    Parameters

    • _f: (e: E) => U

    Returns Result<T, U>

match

  • match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B

    Given 2 functions (one for the Ok variant and one for the Err variant) execute the function that matches the Result variant.

    Match callbacks do not necessitate to return a Result, however you can return a Result if you want to.

    match is like chaining map and mapErr, with the distinction that with match both functions must have the same return type.

    Type Parameters

    • A
    • B = A

    Parameters

    • ok: (t: T) => A
    • _err: (e: E) => B

    Returns A | B

orElse

  • orElse<R extends Result<unknown, unknown>>(
        _f: (e: E) => R,
    ): Result<T | InferOkTypes<R>, InferErrTypes<R>>

    Takes an Err value and maps it to a Result<T, SomeNewType>.

    This is useful for error recovery.

    Type Parameters

    • R extends Result<unknown, unknown>

    Parameters

    • _f: (e: E) => R

    Returns Result<T | InferOkTypes<R>, InferErrTypes<R>>

  • orElse<U, A>(_f: (e: E) => Result<U, A>): Result<T | U, A>

    Type Parameters

    • U
    • A

    Parameters

    • _f: (e: E) => Result<U, A>

    Returns Result<T | U, A>

orTee

  • orTee(_f: (t: E) => unknown): Result<T, E>

    This "tee"s the current Err value to an passed-in computation such as side effect functions but still returns the same Err value as the result.

    This is useful when you want to pass the current Err value to your side-track work such as logging but want to continue error-track work after that. This method does not care about the result of the passed in computation.

    Parameters

    • _f: (t: E) => unknown

    Returns Result<T, E>

safeUnwrap

  • safeUnwrap(): Generator<Err<never, E>, T>

    Returns Generator<Err<never, E>, T>

    Deprecated

    will be removed in 9.0.0.

    You can use safeTry without this method.

    Example

    safeTry(function* () {
      const okValue = yield* yourResult
    })

    Emulates Rust's ? operator in safeTry's body. See also safeTry.

unwrapOr

  • unwrapOr<A>(_v: A): T | A

    Unwrap the Ok value, or return the default if there is an Err

    Type Parameters

    • A

    Parameters

    • _v: A

    Returns T | A

Properties

Readonlyvalue

value: T

Settings

Member Visibility

On This Page

Methods
Properties