Class BaseResult<T, E>Abstract

constructor

• new BaseResult<T, E extends { kind: number }>(): BaseResult<T, E>

  Type Parameters

  • T
  • E extends { kind: number }

  Returns BaseResult<T, E>

Optional Abstract Readonlyerror

Abstract Readonlysuccess

Optional Abstract Readonlyvalue

andThen

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

  Chains computations that may fail.

  If this is Ok, calls fn with the current value. If this is Err, propagates the error unchanged.

  Type Parameters

  • U

  Parameters

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

  Returns Result<U, E>

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

  Chains computations that may fail.

  If this is Ok, calls fn with the current value. If this is Err, propagates the error unchanged.

  Type Parameters

  • U

  Parameters

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

  Returns Promise<Result<U, E>>

isErr

• isErr(): this is Err<E>

  Type guard for narrowing to Err.

  Returns this is Err<E>

isOk

• isOk(): this is Ok<T>

  Type guard for narrowing to Ok.

  Returns this is Ok<T>

map

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

  Transforms the success value while preserving the error type.

  If this is Err, the error is propagated unchanged.

  Type Parameters

  • U

  Parameters

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

  Returns Promise<Result<U, E>>

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

  Transforms the success value while preserving the error type.

  If this is Err, the error is propagated unchanged.

  Type Parameters

  • U

  Parameters

  • fn: (value: T) => U

  Returns Result<U, E>

mapErr

• mapErr<F extends { kind: number }>(
      fn: (error: E) => Promise<F>,
  ): Promise<Result<T, F>>

  Transforms the error value while preserving the success type.

  If this is Ok, the value is propagated unchanged.

  Type Parameters

  • F extends { kind: number }

  Parameters

  • fn: (error: E) => Promise<F>

  Returns Promise<Result<T, F>>

• mapErr<F extends { kind: number }>(fn: (error: E) => F): Result<T, F>

  Transforms the error value while preserving the success type.

  If this is Ok, the value is propagated unchanged.

  Type Parameters

  • F extends { kind: number }

  Parameters

  • fn: (error: E) => F

  Returns Result<T, F>

match

• match<U>(onOk: (value: T) => U, onErr: (error: E) => U): U

  Exhaustively handles both variants and returns a shared result type.

  Type Parameters

  • U

  Parameters

  • onOk: (value: T) => U
  • onErr: (error: E) => U

  Returns U

orElse

• orElse<U, F extends { kind: number }>(
      fn: (error: E) => Result<U, F>,
  ): Result<U, F>

  Recovers from an error by mapping Err<E> to Result<T, F>.

  If this is Ok, the value is preserved.

  Type Parameters

  • U
  • F extends { kind: number }

  Parameters

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

  Returns Result<U, F>

• orElse<U, F extends { kind: number }>(
      fn: (error: E) => Promise<Result<U, F>>,
  ): Promise<Result<U, F>>

  Recovers from an error by mapping Err<E> to Result<T, F>.

  If this is Ok, the value is preserved.

  Type Parameters

  • U
  • F extends { kind: number }

  Parameters

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

  Returns Promise<Result<U, F>>

unwrap

• unwrap(): T

  Returns the success value.

  Returns T

  Throws

  ResultError if called on an Err.

unwrapOr

• unwrapOr<U>(defaultValue: U): T | U

  Returns the success value, or defaultValue if this is an Err.

  Type Parameters

  • U

  Parameters

  • defaultValue: U

  Returns T | U

Staticall

• all<T, E extends { kind: number }>(results: Result<T, E>[]): Result<T[], E>

  Collects an array of results into a single result.

  Returns the first Err encountered, or Ok<T[]> when all succeed.

  Type Parameters

  • T
  • E extends { kind: number }

  Parameters

  • results: Result<T, E>[]

  Returns Result<T[], E>

• all<T, E extends { kind: number }>(
      promises: Promise<Result<T, E>>[],
  ): Promise<Result<T[], E>>

  Async overload of BaseResult.all.

  Type Parameters

  • T
  • E extends { kind: number }

  Parameters

  • promises: Promise<Result<T, E>>[]

  Returns Promise<Result<T[], E>>

Staticany

• any<T, E extends { kind: number }>(results: Result<T, E>[]): Result<T, E>

  Returns the first successful result.

  If all results are errors, returns the last encountered Err.

  Type Parameters

  • T
  • E extends { kind: number }

  Parameters

  • results: Result<T, E>[]

  Returns Result<T, E>

• any<T, E extends { kind: number }>(
      promises: Promise<Result<T, E>>[],
  ): Promise<Result<T, E>>

  Async overload of BaseResult.any.

  Type Parameters

  • T
  • E extends { kind: number }

  Parameters

  • promises: Promise<Result<T, E>>[]

  Returns Promise<Result<T, E>>