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>

Readonlyvalue

_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
  })
  Copy

  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