Class ResultAsync<T, E>

ResultAsync allows you to work with asynchronous Results in a type safe way

ResultAsync<T,E> is a wrapper around Promise<Result<T,E>> which provides the same methods for chaining different Result and ResultAsync together as Result, while also chaining the asynchronous operations together using Promise.then.

ResultAsync is thenable (implements PromiseLike<T>) so can be used in most places that a Promise can, including with await.

Compatible with neverthrow

Type Parameters

  • T

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

  • E

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

Hierarchy (View Summary)

Constructors

constructor

Methods

[asyncIterator] andTee andThen andThrough map mapErr match orElse orTee safeUnwrap then unwrapOr combine combineWithAllErrors fromPromise fromSafePromise fromThrowable

Constructors

constructor

  • new ResultAsync<T, E>(res: Promise<Result<T, E>>): ResultAsync<T, E>

    Type Parameters

    • T
    • E

    Parameters

    • res: Promise<Result<T, E>>

    Returns ResultAsync<T, E>

Methods

[asyncIterator]

  • "[asyncIterator]"(): AsyncGenerator<Err<never, E>, T>

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

andTee

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

    Parameters

    • f: (t: T) => unknown

    Returns ResultAsync<T, E>

andThen

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

    Type Parameters

    • R extends Result<unknown, unknown>

    Parameters

    • f: (t: T) => R

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

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

    Type Parameters

    Parameters

    • f: (t: T) => R

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

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

    Type Parameters

    • U
    • F

    Parameters

    Returns ResultAsync<U, E | F>

andThrough

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

    Type Parameters

    • F

    Parameters

    Returns ResultAsync<T, E | F>

map

  • map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>

    Type Parameters

    • A

    Parameters

    • f: (t: T) => A | Promise<A>

    Returns ResultAsync<A, E>

mapErr

  • mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>

    Type Parameters

    • U

    Parameters

    • f: (e: E) => U | Promise<U>

    Returns ResultAsync<T, U>

match

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

    Type Parameters

    • A
    • B = A

    Parameters

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

    Returns Promise<A | B>

orElse

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

    Type Parameters

    • R extends Result<unknown, unknown>

    Parameters

    • f: (e: E) => R

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

  • orElse<R extends ResultAsync<unknown, unknown>>(
        f: (e: E) => R,
    ): ResultAsync<T | InferAsyncOkTypes<R>, InferAsyncErrTypes<R>>

    Type Parameters

    Parameters

    • f: (e: E) => R

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

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

    Type Parameters

    • U
    • A

    Parameters

    Returns ResultAsync<T | U, A>

orTee

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

    Parameters

    • f: (t: E) => unknown

    Returns ResultAsync<T, E>

safeUnwrap

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

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

    Deprecated

    will be removed in 9.0.0.

    You can use safeTry without this method.

    Example

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

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

then

  • then<A, B>(
        successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,
        failureCallback?: (reason: unknown) => B | PromiseLike<B>,
    ): PromiseLike<A | B>

    Attaches callbacks for the resolution and/or rejection of the Promise.

    Type Parameters

    • A
    • B

    Parameters

    • OptionalsuccessCallback: (res: Result<T, E>) => A | PromiseLike<A>
    • OptionalfailureCallback: (reason: unknown) => B | PromiseLike<B>

    Returns PromiseLike<A | B>

    A Promise for the completion of which ever callback is executed.

unwrapOr

  • unwrapOr<A>(t: A): Promise<T | A>

    Type Parameters

    • A

    Parameters

    Returns Promise<T | A>

Staticcombine

  • combine<
        T extends
            readonly [ResultAsync<unknown, unknown>, ResultAsync<unknown, unknown>],
    >(
        asyncResultList: T,
    ): CombineResultAsyncs<T>

    Type Parameters

    Parameters

    • asyncResultList: T

    Returns CombineResultAsyncs<T>

  • combine<T extends readonly ResultAsync<unknown, unknown>[]>(
        asyncResultList: T,
    ): CombineResultAsyncs<T>

    Type Parameters

    Parameters

    • asyncResultList: T

    Returns CombineResultAsyncs<T>

StaticcombineWithAllErrors

  • combineWithAllErrors<
        T extends
            readonly [ResultAsync<unknown, unknown>, ResultAsync<unknown, unknown>],
    >(
        asyncResultList: T,
    ): CombineResultsWithAllErrorsArrayAsync<T>

    Type Parameters

    Parameters

    • asyncResultList: T

    Returns CombineResultsWithAllErrorsArrayAsync<T>

  • combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(
        asyncResultList: T,
    ): CombineResultsWithAllErrorsArrayAsync<T>

    Type Parameters

    Parameters

    • asyncResultList: T

    Returns CombineResultsWithAllErrorsArrayAsync<T>

StaticfromPromise

  • fromPromise<T, E>(
        promise: PromiseLike<T>,
        errorFn: (e: unknown) => E,
    ): ResultAsync<T, E>

    Type Parameters

    • T
    • E

    Parameters

    • promise: PromiseLike<T>
    • errorFn: (e: unknown) => E

    Returns ResultAsync<T, E>

StaticfromSafePromise

  • fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>

    Type Parameters

    • T
    • E = never

    Parameters

    • promise: PromiseLike<T>

    Returns ResultAsync<T, E>

StaticfromThrowable

  • fromThrowable<A extends readonly any[], R, E>(
        fn: (...args: A) => Promise<R>,
        errorFn?: (err: unknown) => E,
    ): (...args: A) => ResultAsync<R, E>

    Type Parameters

    • A extends readonly any[]
    • R
    • E

    Parameters

    • fn: (...args: A) => Promise<R>
    • OptionalerrorFn: (err: unknown) => E

    Returns (...args: A) => ResultAsync<R, E>

Settings

Member Visibility

On This Page

Constructors
Methods