resultar 1.2.0 → 1.3.1

package/dist/{index-CV4S5Ys9.d.ts → index-DUO8gZOZ.d.ts}

@@ -1,116 +1,30 @@
-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>>> = {
+type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {
     [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never;
 };
-type ExtractOkAsyncTypes<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = {
+type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
     [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never;
 };
-type ExtractErrTypes<T extends ReadonlyArray<Result<unknown, unknown>>> = {
+type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {
     [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never;
 };
-type ExtractErrAsyncTypes<T extends ReadonlyArray<ResultAsync<unknown, unknown>>> = {
+type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {
     [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never;
 };
 type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
 type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
 type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
 type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
-type IsLiteralArray<T> = T extends {
-    length: infer L;
-} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
-type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
-type Prev = [
-    never,
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    8,
-    9,
-    10,
-    11,
-    12,
-    13,
-    14,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    21,
-    22,
-    23,
-    24,
-    25,
-    26,
-    27,
-    28,
-    29,
-    30,
-    31,
-    32,
-    33,
-    34,
-    35,
-    36,
-    37,
-    38,
-    39,
-    40,
-    41,
-    42,
-    43,
-    44,
-    45,
-    46,
-    47,
-    48,
-    49,
-    ...Array<0>
-];
-type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
-type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [
-    Depth
-] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [
-    ...Collected,
-    [L, R]
-], Prev[Depth]> : never : Collected;
-type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
-type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
-type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [
-    infer L,
-    infer R
-] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
-type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
-type TraverseWithAllErrors<T, Depth extends number = 5> = Combine<T, Depth> extends [
-    infer Oks,
-    infer Errs
-] ? Result<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>> : never;
-type CombineResults<T extends ReadonlyArray<Result<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
-type CombineResultsWithAllErrorsArray<T extends ReadonlyArray<Result<unknown, unknown>>> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, Array<ExtractErrTypes<T>[number]>>;
-declare const combineResultAsyncList: <T, E>(asyncResultList: ReadonlyArray<ResultAsync<T, E>>) => ResultAsync<readonly T[], E>;
 /**
  * Short circuits on the FIRST Err value that we find
  */
-declare const combineResultList: <T, E>(resultList: ReadonlyArray<Result<T, E>>) => Result<readonly T[], E>;
-declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: ReadonlyArray<ResultAsync<T, E>>) => ResultAsync<readonly T[], E[]>;
+declare const combineResultList: <T, E>(resultList: readonly Result<T, E>[]) => Result<readonly T[], E>;
+declare const combineResultAsyncList: <T, E>(asyncResultList: readonly ResultAsync<T, E>[]) => ResultAsync<readonly T[], E>;
 /**
  * Give a list of all the errors we find
  */
-declare const combineResultListWithAllErrors: <T, E>(resultList: ReadonlyArray<Result<T, E>>) => Result<readonly T[], E[]>;
+declare const combineResultListWithAllErrors: <T, E>(resultList: readonly Result<T, E>[]) => Result<readonly T[], E[]>;
+declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: readonly ResultAsync<T, E>[]) => ResultAsync<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>>);
@@ -159,10 +73,10 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
      * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type 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>;
+    static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
+    static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+    static combineWithAllErrors<T extends readonly 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
@@ -189,7 +103,7 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, 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>;
+    match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
     unwrapOr<A>(t: A): Promise<T | A>;
     /**
      * Performs a side effect for the `Ok` variant of `ResultAsync`.
@@ -219,25 +133,25 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
      */
     safeUnwrap(): AsyncGenerator<Result<never, E>, T>;
 }
+/**
+ * @deprecated Use `safeTry` instead.
+ * @see `safeTry`
+ *
+ * This will be removed in the next major version.
+ */
+declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
 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 unitAsync: typeof ResultAsync.unitAsync;
 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 CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
+type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, 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 (infer A)[] ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? 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 (infer I)[] ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
+type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
+type Writable<T> = T extends readonly unknown[] ? [...T] : T;
 
 /**
  * A Result interface that is used to define the methods that are available on a
@@ -314,10 +228,10 @@ declare class Result<T, E> implements Resultable<T, E> {
      */
     static unit<E = never>(): Result<undefined, E>;
     static err<T = never, E = unknown>(error: E): Result<T, E>;
-    static combine<T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>]>(resultList: T): CombineResults<T>;
-    static combine<T extends ReadonlyArray<Result<unknown, unknown>>>(resultList: T): CombineResults<T>;
-    static combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
-    static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+    static combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
+    static combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResults<T>;
+    static combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
+    static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
     readonly value: T;
     readonly error: E;
     private constructor();
@@ -414,7 +328,7 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param ok
      * @param err
      */
-    match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
+    match<A, B = A>(fnOk: (t: T) => A, fnErr: (e: E) => B): A | B;
     /**
      * Performs a side effect for the `Ok` or `Err` variant of `Result`.
      *
@@ -470,17 +384,13 @@ declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
     constructor(result: Resultable<T, E>, finalizer: (value: T, error: E) => void);
     get value(): T;
     get error(): E;
-    _unsafeUnwrap(config?: ErrorConfig | undefined): T;
-    _unsafeUnwrapErr(config?: ErrorConfig | undefined): E;
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
     isOk(): boolean;
     isErr(): boolean;
     unwrapOr<A>(defaultValue: A): T | A;
     [Symbol.dispose](): void;
 }
-declare const ok: typeof Result.ok;
-declare const err: typeof Result.err;
-declare const fromThrowable: typeof Result.fromThrowable;
-declare const unit: typeof Result.unit;
 /**
  * Evaluates the given generator to a Result returned or an Err yielded from it,
  * whichever comes first.
@@ -494,6 +404,7 @@ declare const unit: typeof Result.unit;
  * @returns The first occurence of either an yielded Err or a returned Result.
  */
 declare function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(body: () => Generator<YieldErr, GeneratorReturnResult>): Result<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
 /**
  * Evaluates the given generator to a Result returned or an Err yielded from it,
  * whichever comes first.
@@ -506,7 +417,89 @@ declare function safeTry<T, E>(body: () => Generator<Result<never, E>, Result<T,
  * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.
  * @returns The first occurence of either an yielded Err or a returned Result.
  */
-declare function safeTry<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): Promise<Result<T, E>>;
+declare function safeTry<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
+declare function safeTry<YieldErr extends Result<never, unknown>, GeneratorReturnResult extends Result<unknown, unknown>>(body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>): ResultAsync<InferOkTypes<GeneratorReturnResult>, InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>>;
+declare const ok: typeof Result.ok;
+declare const err: typeof Result.err;
+declare const fromThrowable: typeof Result.fromThrowable;
+declare const unit: typeof Result.unit;
+type Prev = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    32,
+    33,
+    34,
+    35,
+    36,
+    37,
+    38,
+    39,
+    40,
+    41,
+    42,
+    43,
+    44,
+    45,
+    46,
+    47,
+    48,
+    49,
+    ...0[]
+];
+type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [
+    Depth
+] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [
+    ...Collected,
+    [L, R]
+], Prev[Depth]> : never : Collected;
+type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [
+    infer L,
+    infer R
+] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+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 EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+type IsLiteralArray<T> = T extends {
+    length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
+type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
 
 interface ErrorConfig {
     withStackTrace: boolean;
@@ -524,4 +517,4 @@ interface ResultarError<T, E> extends Error {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { DisposableResult as A, ok as B, type Combine as C, type Dedup as D, type ExtractOkTypes as E, err as F, fromThrowable as G, unit as H, type InferOkTypes as I, safeTry as J, type ErrorConfig as K, createResultarError as L, 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, unitAsync as w, fromThrowableAsync as x, safeTryAsync as y, Result as z };
+export { type Dedup as A, type EmptyArrayToNever as B, type CombineResultAsyncs as C, DisposableResultAsync as D, type ExtractOkTypes as E, type MembersToUnion as F, type IsLiteralArray as G, type CombineResults as H, type InferOkTypes as I, type CombineResultsWithAllErrorsArray as J, type ErrorConfig as K, createResultarError as L, 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, combineResultList as g, combineResultAsyncList as h, combineResultListWithAllErrors as i, combineResultAsyncListWithAllErrors as j, errAsync as k, fromPromise as l, fromSafePromise as m, fromThrowableAsync as n, okAsync as o, type CombineResultsWithAllErrorsArrayAsync as p, Result as q, DisposableResult as r, safeTryAsync as s, safeTry as t, unitAsync as u, ok as v, err as w, fromThrowable as x, unit as y, type Combine as z };

package/dist/index.cjs

@@ -53,9 +53,6 @@ var createResultarError = (message, result, config = defaultErrorConfig) => {
 };
 
 // src/utils.ts
-var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
-  combineResultList
-);
 var combineResultList = (resultList) => {
   let acc = ok([]);
   for (const result of resultList) {
@@ -68,12 +65,9 @@ var combineResultList = (resultList) => {
   }
   return acc;
 };
-var combineResultAsyncListWithAllErrors = (asyncResultList) => {
-  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
-    combineResultListWithAllErrors
-  );
-  return x;
-};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
+  combineResultList
+);
 var combineResultListWithAllErrors = (resultList) => {
   let acc = ok([]);
   for (const result of resultList) {
@@ -87,6 +81,9 @@ var combineResultListWithAllErrors = (resultList) => {
   }
   return acc;
 };
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
+  combineResultListWithAllErrors
+);
 
 // src/result.ts
 var Ok = class {
@@ -413,14 +410,17 @@ var DisposableResult = class {
     this.finalizer(this.result.value, this.result.error);
   }
 };
-var { ok, err, fromThrowable, unit } = Result;
 function safeTry(body) {
   const n = body().next();
   if (n instanceof Promise) {
-    return n.then((r) => r.value);
+    return new ResultAsync(n.then((r) => r.value));
   }
   return n.value;
 }
+var ok = Result.ok;
+var err = Result.err;
+var fromThrowable = Result.fromThrowable;
+var unit = Result.unit;
 
 // src/result-async.ts
 var DisposableResultAsync = class {
@@ -560,8 +560,8 @@ var ResultAsync = class _ResultAsync {
       })
     );
   }
-  async match(ok2, err2) {
-    return this.innerPromise.then((res) => res.match(ok2, err2));
+  async match(ok2, fnErr) {
+    return this.innerPromise.then((res) => res.match(ok2, fnErr));
   }
   async unwrapOr(t) {
     return this.innerPromise.then((res) => res.unwrapOr(t));
@@ -650,8 +650,6 @@ var ResultAsync = class _ResultAsync {
     return yield* await this.innerPromise.then((res) => res.safeUnwrap());
   }
 };
-var { okAsync, errAsync, fromPromise, fromSafePromise, unitAsync } = ResultAsync;
-var fromThrowableAsync = ResultAsync.fromThrowable;
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -663,6 +661,12 @@ function safeTryAsync(body) {
     })()
   );
 }
+var okAsync = ResultAsync.okAsync;
+var errAsync = ResultAsync.errAsync;
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var unitAsync = ResultAsync.unitAsync;
+var fromThrowableAsync = ResultAsync.fromThrowable;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Result,