Class Ok<T, E>

constructor

• new Ok<T, E>(value: T): Ok<T, E>

• Type Parameters

  • T
  • E

  Parameters

  • value: T

  Returns Ok<T, E>

Readonly value

_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

  • Optional config: ErrorConfig

  Returns 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

    • • (t: T): R

      • Parameters

        • t: T

        Returns R

  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>)
    • • (t: T): Result<U, F>

      • Parameters

        • t: T

        Returns Result<U, F>

  Returns Result<U, 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

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

      • Parameters

        • t: T

        Returns ResultAsync<U, F>

  Returns ResultAsync<U, 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

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

      • Parameters

        • t: T

        Returns Promise<U>

  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

    • • (t: T): A

      • Parameters

        • t: T

        Returns A

  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)

    a function to apply to the error Err value

    • • (e: E): U

      • Parameters

        • e: E

        Returns U

  Returns Result<T, U>

match

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

• 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

  Parameters

  • ok: ((t: T) => A)
    • • (t: T): A

      • Parameters

        • t: T

        Returns A

  • _err: ((e: E) => A)
    • • (e: E): A

      • Parameters

        • e: E

        Returns A

  Returns A

orElse

• orElse<R extends Result<unknown, unknown>>(_f: ((e: E) => R)): Result<T, 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)

    A function to apply to an Err value, leaving Ok values untouched.

    • • (e: E): R

      • Parameters

        • e: E

        Returns R

  Returns Result<T, InferErrTypes<R>>
• orElse<A>(_f: ((e: E) => Result<T, A>)): Result<T, A>

• Type Parameters

  • A

  Parameters

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

      • Parameters

        • e: E

        Returns Result<T, A>

  Returns Result<T, A>

safeUnwrap

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

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

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

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

    the default value to return if there is an Err

  Returns T | A