Class Ok<T>

constructor

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

  Type Parameters

  • T

  Parameters

  • value: T

  Returns Ok<T>

Readonly_tag

[toStringTag]

• get "[toStringTag]"(): string

  Returns string

error

• get error(): null

  The error, if available.

  Returns null

value

• get value(): T

  The good value, if available.

  Returns T

[iterator]

• "[iterator]"(): IterableIterator<T>

  Returns IterableIterator<T>

and

• and<U>(result: Result<U, never>): Result<U, never>

  Returns the passed value if this is Ok, otherwise returns this.

  Type Parameters

  • U

  Parameters

  • result: Result<U, never>

  Returns Result<U, never>

andThen

• andThen<U, F>(fn: (value: T) => Result<U, F>): Result<U, F>

  Maps a Result<T, E> to Result<U, E | F> by applying a function to a contained Ok value, producing a new result.

  Type Parameters

  • U
  • F

  Parameters

  • fn: (value: T) => Result<U, F>

  Returns Result<U, F>

andThenAsync

• andThenAsync<U, F>(
      fn: (value: T) => Promise<Result<U, F>>,
  ): Promise<Result<U, F>>

  Maps a Result<T, E> to Promise<Result<U, E | F>> by applying a function to a contained Ok value, producing a new async result.

  Type Parameters

  • U
  • F

  Parameters

  • fn: (value: T) => Promise<Result<U, F>>

  Returns Promise<Result<U, F>>

err

• err(): Option<never>

  Returns an option of the inner error of a result.

  Returns Option<never>

expect

• expect(message: string): T

  Unwraps a result, yielding the value.

  USE THIS SPARINGLY! It is generally better to use unwrapOr or map to handle situations you may be temped to .expect() in.

  This is good for using in tests.

  Parameters

  • message: string

  Returns T

  Throws

  A new error with the provided message, if the result is an Err.

expectErr

• expectErr(message: string): never

  Unwraps a result, yielding the error.

  USE THIS SPARINGLY! It is generally better to use unwrapOr or map to handle situations you may be temped to .expect() in.

  This is good for using in tests.

  Parameters

  • message: string

  Returns never

  Throws

  A new error with the provided message, if the result is an Ok.

inspect

• inspect(fn: (value: T) => void): Ok<T>

  Allows inspection of the interior result value, if it is Ok. May be useful in cases where you do not want to modify the result.

  Parameters

  • fn: (value: T) => void

  Returns Ok<T>

inspectErr

• inspectErr(): Ok<T>

  Allows inspection of the interior error value, if it is Err. May be useful in cases where you do not want to modify the error.

  Returns Ok<T>

isErr

• isErr(): this is Err<never>

  Asserts that the current result is Err.

  Returns this is Err<never>

isErrAnd

• isErrAnd(fn: (error: never) => boolean): this is Err<never>

  Asserts that the current result is Err and the error passes the given predicate.

  Parameters

  • fn: (error: never) => boolean

  Returns this is Err<never>

isOk

• isOk(): this is Ok<T>

  Asserts that the current result is Ok.

  Returns this is Ok<T>

isOkAnd

• isOkAnd(fn: (value: T) => boolean): this is Ok<T>

  Asserts that the current result is Ok and the value passes the given predicate.

  Parameters

  • fn: (value: T) => boolean

  Returns this is Ok<T>

iter

• iter(): IterableIterator<T>

  Returns IterableIterator<T>

map

• map<U>(fn: (value: T) => U): Ok<U>

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

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => U

  Returns Ok<U>

mapAsync

• mapAsync<U>(fn: (value: T) => Promise<U>): Promise<Ok<U>>

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

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => Promise<U>

  Returns Promise<Ok<U>>

mapErr

• mapErr<F>(fn: (error: never) => F): Ok<T>

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

  Type Parameters

  • F

  Parameters

  • fn: (error: never) => F

  Returns Ok<T>

mapOr

• mapOr<U>(fn: (value: T) => U, fallback: U): U

  Maps a Result<T, E> to U by applying a function to a contained Ok value. If the result is an Err, the fallback value will be returned.

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => U
  • fallback: U

  Returns U

mapOrAsync

• mapOrAsync<U>(fn: (value: T) => Promise<U>, fallback: U): Promise<U>

  Maps a Result<T, E> to Promise by applying a function to a contained Ok value. If the result is an Err, the fallback value will be returned.

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => Promise<U>
  • fallback: U

  Returns Promise<U>

mapOrElse

• mapOrElse<U>(fn: (value: T) => U, fallback: () => U): U

  Maps a Result<T, E> to U by applying a function to a contained Ok value. If the result is an Err, the fallback function will be called and its result will be returned.

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => U
  • fallback: () => U

  Returns U

mapOrElseAsync

• mapOrElseAsync<U>(
      fn: (value: T) => Promise<U>,
      fallback: () => Promise<U>,
  ): Promise<U>

  Maps a Result<T, E> to Promise by applying a function to a contained Ok value. If the result is an Err, the fallback function will be called and its result will be returned.

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => Promise<U>
  • fallback: () => Promise<U>

  Returns Promise<U>

ok

• ok(): Option<T>

  Returns an option of the inner value of a result.

  Returns Option<T>

or

• or<U = T, F = never>(result: Result<U, F>): Ok<T>

  Returns the passed value if this is Err, otherwise returns this.

  Type Parameters

  • U = T
  • F = never

  Parameters

  • result: Result<U, F>

  Returns Ok<T>

orElse

• orElse<U = T, F = never>(fn: (error: never) => Result<U, F>): Ok<T>

  Calls fn if the result is an Err, otherwise returns this.

  Type Parameters

  • U = T
  • F = never

  Parameters

  • fn: (error: never) => Result<U, F>

  Returns Ok<T>

toString

• toString(): string

  Returns a string representation of the result for debugging purposes.

  Returns string

unwrap

• unwrap(): T

  Returns the inner value of a result, if it is Ok. Otherwise, the contained error will be thrown.

  USE THIS SPARINGLY! It is generally better to use unwrapOr or map to handle situations you may be temped to .unwrap() in.

  Returns T

  Throws

  The contained error, if the result is an Err.

unwrapOr

• unwrapOr<V>(fallback: T | V): T | V

  Returns the inner value of a result, if it is Ok. Otherwise, the provided fallback value will be returned.

  Type Parameters

  • V

  Parameters

  • fallback: T | V

  Returns T | V

unwrapOrElse

• unwrapOrElse<V>(fn: (error: never) => T | V): T

  Returns the inner value of a result, if it is Ok. Otherwise, the provided fallback funtion will be called and its result will be returned.

  Type Parameters

  • V

  Parameters

  • fn: (error: never) => T | V

  Returns T