resultar 1.1.3 → 1.1.5

package/dist/{index-BH-Kjtur.d.cts → index-CKLj0kyj.d.cts}

@@ -1,92 +1,3 @@
-type CombineResultAsyncs<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
-type CombineResultsWithAllErrorsArrayAsync<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>;
-type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Array<Result<L, R>> : never : never : never;
-type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
-type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>> : never : Writable<T> extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
-type Writable<T> = T extends readonly unknown[] ? [...T] : T;
-declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-    private readonly innerPromise;
-    constructor(res: Promise<Result<T, E>>);
-    then<A, B>(// eslint-disable-line unicorn/no-thenable
-    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-}
-declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-    static okAsync<T, E = never>(value: T): ResultAsync<T, E>;
-    static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
-    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultAsyncs<T>;
-    static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultAsyncs<T>;
-    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-    static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-    /**
-   * Wraps a async function with a try catch, creating a new function with the same
-   * arguments but returning `Ok` if successful, `Err` if the function throws
-   *
-   * @param fn function to wrap with ok on success or err on failure
-   * @param errorFn when an error is thrown, this will wrap the error result if provided
-   * @returns a new function that returns a `ResultAsync`
-   */
-    static fromThrowable<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
-    private readonly innerPromise;
-    constructor(res: Promise<Result<T, E>>);
-    then<A, B>(// eslint-disable-line unicorn/no-thenable
-    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
-    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
-    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
-    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
-    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
-    if(fCondition: (t: T) => boolean): {
-        true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {
-            false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>;
-        };
-    };
-    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
-    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
-    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
-    match<X>(ok: (t: T) => X, err: (e: E) => X): Promise<X>;
-    unwrapOr<A>(t: A): Promise<T | A>;
-    /**
-     * Performs a side effect for the `Ok` variant of `ResultAsync`.
-     * This function can be used for control flow based on result values.
-     * @param f The function to call if the result is `Ok`
-     * @returns `self` if the result is `Err`, otherwise the result of `f`
-     */
-    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
-    /**
-    * Performs a side effect for the `Err` variant of `ResultAsync`.
-    * This function can be used for control flow based on result values.
-    * @param f The function to call if the result is `Err`
-    * @returns `self` if the result is `Ok`, otherwise the result of `f`
-    * @example
-    */
-    tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
-    finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
-    /**
-     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-     */
-    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
-}
-declare const okAsync: typeof ResultAsync.okAsync;
-declare const errAsync: typeof ResultAsync.errAsync;
-declare const fromPromise: typeof ResultAsync.fromPromise;
-declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
-declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
-/**
- * Evaluates the given generator to a Result returned or an Err yielded from it,
- * whichever comes first.
- *
- * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
- * Rust's ? operator.
- * See `/tests/safeTry.test.ts` for examples.
- *
- * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
- * Rust's `result?` expression.
- * @returns The first occurence of either an yielded Err or a returned `ResultAsync`.
- */
-declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
-
 type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR> : T;
 type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W] : [];
 type ExtractOkTypes<T extends ReadonlyArray<Result<unknown, unknown>>> = {
@@ -194,6 +105,102 @@ declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: Reado
  */
 declare const combineResultListWithAllErrors: <T, E>(resultList: ReadonlyArray<Result<T, E>>) => Result<readonly T[], E[]>;
 
+type CombineResultAsyncs<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+type CombineResultsWithAllErrorsArrayAsync<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>;
+type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Array<Result<L, R>> : never : never : never;
+type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
+type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>> : never : Writable<T> extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
+type Writable<T> = T extends readonly unknown[] ? [...T] : T;
+declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+}
+declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    static okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+    static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    /**
+     * Wraps a async function with a try catch, creating a new function with the same
+     * arguments but returning `Ok` if successful, `Err` if the function throws
+     *
+     * @param fn function to wrap with ok on success or err on failure
+     * @param errorFn when an error is thrown, this will wrap the error result if provided
+     * @returns a new function that returns a `ResultAsync`
+     */
+    static fromThrowable<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
+    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+    if(fCondition: (t: T) => boolean): {
+        true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {
+            false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>;
+        };
+    };
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+    match<X>(ok: (t: T) => X, err: (e: E) => X): Promise<X>;
+    unwrapOr<A>(t: A): Promise<T | A>;
+    /**
+     * Performs a side effect for the `Ok` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Ok`
+     * @returns `self` if the result is `Err`, otherwise the result of `f`
+     */
+    log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E>;
+    /**
+     * Performs a side effect for the `Ok` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Ok`
+     * @returns `self` if the result is `Err`, otherwise the result of `f`
+     */
+    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
+    /**
+     * Performs a side effect for the `Err` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Err`
+     * @returns `self` if the result is `Ok`, otherwise the result of `f`
+     * @example
+     */
+    tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
+    finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
+    /**
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
+}
+declare const okAsync: typeof ResultAsync.okAsync;
+declare const errAsync: typeof ResultAsync.errAsync;
+declare const fromPromise: typeof ResultAsync.fromPromise;
+declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
+declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
+ * Rust's ? operator.
+ * See `/tests/safeTry.test.ts` for examples.
+ *
+ * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
+ * Rust's `result?` expression.
+ * @returns The first occurence of either an yielded Err or a returned `ResultAsync`.
+ */
+declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+
 /**
  * A Result interface that is used to define the methods that are available on a
  * `Result` object.
@@ -316,7 +323,6 @@ declare class Result<T, E> implements Resultable<T, E> {
      *
      * This is useful for error recovery.
      *
-     *
      * @param f  A function to apply to an `Err` value, leaving `Ok` values
      * untouched.
      */
@@ -346,7 +352,6 @@ declare class Result<T, E> implements Resultable<T, E> {
      */
     unwrapOr<A>(defaultValue: A): T | A;
     /**
-     *
      * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
      * execute the function that matches the `Result` variant.
      *
@@ -360,20 +365,27 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param err
      */
     match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
+    /**
+     * Performs a side effect no matter what the `Result` variant is.
+     *
+     * @param fn The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    log(fn: (t?: T, e?: E) => void): this;
     /**
      * Performs a side effect for the `Ok` variant of `Result`.
      *
      * @param fn The function to apply an `OK` value
      * @returns the result of applying `f` or an `Err` untouched
      */
-    tap(fn: (t: T) => void): Result<T, E>;
+    tap(fn: (t: T) => void): this;
     /**
      * Performs a side effect for the `Err` variant of `Result`.
      *
      * @param fn The function to apply an `Err` value
      * @returns the result of applying `f` or an `Ok` untouched
      */
-    tapError(fn: (e: E) => void): Result<T, E>;
+    tapError(fn: (e: E) => void): this;
     /**
      * This method is used to clean up and release any resources that the `Result`
      * @param f The function that will be called to clean up the resources
@@ -461,4 +473,4 @@ interface ResultarError<T, E> {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { ok as A, err as B, type CombineResultAsyncs as C, DisposableResultAsync as D, type ExtractOkTypes as E, fromThrowable as F, safeTry as G, type ErrorConfig as H, type InferOkTypes as I, createResultarError as J, type MemberListOf as M, ResultAsync as R, type Transpose as T, type CombineResultsWithAllErrorsArrayAsync as a, fromSafePromise as b, fromThrowableAsync as c, type Dedup as d, errAsync as e, fromPromise as f, type ExtractOkAsyncTypes as g, type ExtractErrTypes as h, type ExtractErrAsyncTypes as i, type InferErrTypes as j, type InferAsyncOkTypes as k, type InferAsyncErrTypes as l, type IsLiteralArray as m, type EmptyArrayToNever as n, okAsync as o, type MembersToUnion as p, type Combine as q, type CombineResults as r, safeTryAsync as s, type CombineResultsWithAllErrorsArray as t, combineResultAsyncList as u, combineResultList as v, combineResultAsyncListWithAllErrors as w, combineResultListWithAllErrors as x, Result as y, DisposableResult as z };
+export { ok as A, err as B, type Combine as C, type Dedup as D, type ExtractOkTypes as E, fromThrowable as F, safeTry as G, type ErrorConfig as H, type InferOkTypes as I, createResultarError as J, type MemberListOf as M, ResultAsync as R, type Transpose as T, type ExtractOkAsyncTypes as a, type ExtractErrTypes as b, type ExtractErrAsyncTypes as c, type InferErrTypes as d, type InferAsyncOkTypes as e, type InferAsyncErrTypes as f, type IsLiteralArray as g, type EmptyArrayToNever as h, type MembersToUnion as i, type CombineResults as j, type CombineResultsWithAllErrorsArray as k, combineResultAsyncList as l, combineResultList as m, combineResultAsyncListWithAllErrors as n, combineResultListWithAllErrors as o, type CombineResultAsyncs as p, type CombineResultsWithAllErrorsArrayAsync as q, DisposableResultAsync as r, okAsync as s, errAsync as t, fromPromise as u, fromSafePromise as v, fromThrowableAsync as w, safeTryAsync as x, Result as y, DisposableResult as z };

package/dist/{index-BH-Kjtur.d.ts → index-CKLj0kyj.d.ts}

@@ -1,92 +1,3 @@
-type CombineResultAsyncs<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
-type CombineResultsWithAllErrorsArrayAsync<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>;
-type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Array<Result<L, R>> : never : never : never;
-type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
-type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>> : never : Writable<T> extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
-type Writable<T> = T extends readonly unknown[] ? [...T] : T;
-declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-    private readonly innerPromise;
-    constructor(res: Promise<Result<T, E>>);
-    then<A, B>(// eslint-disable-line unicorn/no-thenable
-    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-}
-declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-    static okAsync<T, E = never>(value: T): ResultAsync<T, E>;
-    static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
-    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultAsyncs<T>;
-    static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultAsyncs<T>;
-    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-    static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-    /**
-   * Wraps a async function with a try catch, creating a new function with the same
-   * arguments but returning `Ok` if successful, `Err` if the function throws
-   *
-   * @param fn function to wrap with ok on success or err on failure
-   * @param errorFn when an error is thrown, this will wrap the error result if provided
-   * @returns a new function that returns a `ResultAsync`
-   */
-    static fromThrowable<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
-    private readonly innerPromise;
-    constructor(res: Promise<Result<T, E>>);
-    then<A, B>(// eslint-disable-line unicorn/no-thenable
-    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
-    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
-    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
-    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
-    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
-    if(fCondition: (t: T) => boolean): {
-        true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {
-            false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>;
-        };
-    };
-    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
-    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
-    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
-    match<X>(ok: (t: T) => X, err: (e: E) => X): Promise<X>;
-    unwrapOr<A>(t: A): Promise<T | A>;
-    /**
-     * Performs a side effect for the `Ok` variant of `ResultAsync`.
-     * This function can be used for control flow based on result values.
-     * @param f The function to call if the result is `Ok`
-     * @returns `self` if the result is `Err`, otherwise the result of `f`
-     */
-    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
-    /**
-    * Performs a side effect for the `Err` variant of `ResultAsync`.
-    * This function can be used for control flow based on result values.
-    * @param f The function to call if the result is `Err`
-    * @returns `self` if the result is `Ok`, otherwise the result of `f`
-    * @example
-    */
-    tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
-    finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
-    /**
-     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-     */
-    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
-}
-declare const okAsync: typeof ResultAsync.okAsync;
-declare const errAsync: typeof ResultAsync.errAsync;
-declare const fromPromise: typeof ResultAsync.fromPromise;
-declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
-declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
-/**
- * Evaluates the given generator to a Result returned or an Err yielded from it,
- * whichever comes first.
- *
- * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
- * Rust's ? operator.
- * See `/tests/safeTry.test.ts` for examples.
- *
- * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
- * Rust's `result?` expression.
- * @returns The first occurence of either an yielded Err or a returned `ResultAsync`.
- */
-declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
-
 type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR> : T;
 type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends infer U ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V : never : never) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W] : [];
 type ExtractOkTypes<T extends ReadonlyArray<Result<unknown, unknown>>> = {
@@ -194,6 +105,102 @@ declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: Reado
  */
 declare const combineResultListWithAllErrors: <T, E>(resultList: ReadonlyArray<Result<T, E>>) => Result<readonly T[], E[]>;
 
+type CombineResultAsyncs<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+type CombineResultsWithAllErrorsArrayAsync<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, Array<ExtractErrAsyncTypes<T>[number]>>;
+type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Array<Result<L, R>> : never : never : never;
+type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
+type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>> : never : Writable<T> extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>> : ResultAsync<Oks, Errs> : never : never;
+type Writable<T> = T extends readonly unknown[] ? [...T] : T;
+declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+}
+declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    static okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+    static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+    static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
+    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...Array<ResultAsync<unknown, unknown>>]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    /**
+     * Wraps a async function with a try catch, creating a new function with the same
+     * arguments but returning `Ok` if successful, `Err` if the function throws
+     *
+     * @param fn function to wrap with ok on success or err on failure
+     * @param errorFn when an error is thrown, this will wrap the error result if provided
+     * @returns a new function that returns a `ResultAsync`
+     */
+    static fromThrowable<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
+    private readonly innerPromise;
+    constructor(res: Promise<Result<T, E>>);
+    then<A, B>(// eslint-disable-line unicorn/no-thenable
+    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
+    mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U>;
+    map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E>;
+    andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
+    andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
+    andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
+    if(fCondition: (t: T) => boolean): {
+        true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {
+            false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>;
+        };
+    };
+    orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
+    orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
+    orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
+    match<X>(ok: (t: T) => X, err: (e: E) => X): Promise<X>;
+    unwrapOr<A>(t: A): Promise<T | A>;
+    /**
+     * Performs a side effect for the `Ok` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Ok`
+     * @returns `self` if the result is `Err`, otherwise the result of `f`
+     */
+    log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E>;
+    /**
+     * Performs a side effect for the `Ok` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Ok`
+     * @returns `self` if the result is `Err`, otherwise the result of `f`
+     */
+    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
+    /**
+     * Performs a side effect for the `Err` variant of `ResultAsync`.
+     * This function can be used for control flow based on result values.
+     * @param f The function to call if the result is `Err`
+     * @returns `self` if the result is `Ok`, otherwise the result of `f`
+     * @example
+     */
+    tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E>;
+    finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E>;
+    /**
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
+}
+declare const okAsync: typeof ResultAsync.okAsync;
+declare const errAsync: typeof ResultAsync.errAsync;
+declare const fromPromise: typeof ResultAsync.fromPromise;
+declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
+declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
+/**
+ * Evaluates the given generator to a Result returned or an Err yielded from it,
+ * whichever comes first.
+ *
+ * This function, in combination with `Result.safeUnwrap()`, is intended to emulate
+ * Rust's ? operator.
+ * See `/tests/safeTry.test.ts` for examples.
+ *
+ * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as
+ * Rust's `result?` expression.
+ * @returns The first occurence of either an yielded Err or a returned `ResultAsync`.
+ */
+declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+
 /**
  * A Result interface that is used to define the methods that are available on a
  * `Result` object.
@@ -316,7 +323,6 @@ declare class Result<T, E> implements Resultable<T, E> {
      *
      * This is useful for error recovery.
      *
-     *
      * @param f  A function to apply to an `Err` value, leaving `Ok` values
      * untouched.
      */
@@ -346,7 +352,6 @@ declare class Result<T, E> implements Resultable<T, E> {
      */
     unwrapOr<A>(defaultValue: A): T | A;
     /**
-     *
      * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
      * execute the function that matches the `Result` variant.
      *
@@ -360,20 +365,27 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param err
      */
     match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
+    /**
+     * Performs a side effect no matter what the `Result` variant is.
+     *
+     * @param fn The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    log(fn: (t?: T, e?: E) => void): this;
     /**
      * Performs a side effect for the `Ok` variant of `Result`.
      *
      * @param fn The function to apply an `OK` value
      * @returns the result of applying `f` or an `Err` untouched
      */
-    tap(fn: (t: T) => void): Result<T, E>;
+    tap(fn: (t: T) => void): this;
     /**
      * Performs a side effect for the `Err` variant of `Result`.
      *
      * @param fn The function to apply an `Err` value
      * @returns the result of applying `f` or an `Ok` untouched
      */
-    tapError(fn: (e: E) => void): Result<T, E>;
+    tapError(fn: (e: E) => void): this;
     /**
      * This method is used to clean up and release any resources that the `Result`
      * @param f The function that will be called to clean up the resources
@@ -461,4 +473,4 @@ interface ResultarError<T, E> {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { ok as A, err as B, type CombineResultAsyncs as C, DisposableResultAsync as D, type ExtractOkTypes as E, fromThrowable as F, safeTry as G, type ErrorConfig as H, type InferOkTypes as I, createResultarError as J, type MemberListOf as M, ResultAsync as R, type Transpose as T, type CombineResultsWithAllErrorsArrayAsync as a, fromSafePromise as b, fromThrowableAsync as c, type Dedup as d, errAsync as e, fromPromise as f, type ExtractOkAsyncTypes as g, type ExtractErrTypes as h, type ExtractErrAsyncTypes as i, type InferErrTypes as j, type InferAsyncOkTypes as k, type InferAsyncErrTypes as l, type IsLiteralArray as m, type EmptyArrayToNever as n, okAsync as o, type MembersToUnion as p, type Combine as q, type CombineResults as r, safeTryAsync as s, type CombineResultsWithAllErrorsArray as t, combineResultAsyncList as u, combineResultList as v, combineResultAsyncListWithAllErrors as w, combineResultListWithAllErrors as x, Result as y, DisposableResult as z };
+export { ok as A, err as B, type Combine as C, type Dedup as D, type ExtractOkTypes as E, fromThrowable as F, safeTry as G, type ErrorConfig as H, type InferOkTypes as I, createResultarError as J, type MemberListOf as M, ResultAsync as R, type Transpose as T, type ExtractOkAsyncTypes as a, type ExtractErrTypes as b, type ExtractErrAsyncTypes as c, type InferErrTypes as d, type InferAsyncOkTypes as e, type InferAsyncErrTypes as f, type IsLiteralArray as g, type EmptyArrayToNever as h, type MembersToUnion as i, type CombineResults as j, type CombineResultsWithAllErrorsArray as k, combineResultAsyncList as l, combineResultList as m, combineResultAsyncListWithAllErrors as n, combineResultListWithAllErrors as o, type CombineResultAsyncs as p, type CombineResultsWithAllErrorsArrayAsync as q, DisposableResultAsync as r, okAsync as s, errAsync as t, fromPromise as u, fromSafePromise as v, fromThrowableAsync as w, safeTryAsync as x, Result as y, DisposableResult as z };