resultar 1.1.5 → 1.3.0

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

@@ -1,131 +1,82 @@
-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>>);
     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>;
 }
+/**
+ * The ResultAsync type.
+ * This is a union of `Result` and `PromiseLike<Result>`
+ */
 declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    /**
+     * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).
+     *
+     * @param {T} value - The value to be wrapped in a Result.ok.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.
+     */
     static okAsync<T, E = never>(value: T): ResultAsync<T, E>;
+    /**
+     * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
+     *
+     * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
+     */
+    static unitAsync<E = never>(): ResultAsync<undefined, E>;
+    /**
+     * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).
+     *
+     * @param {E} error - The error to be wrapped in a Result.err.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.
+     */
     static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+    /**
+     * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
+     * based on the provided promise.
+     *
+     * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
+     * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.
+     */
     static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
+    /**
+     * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)
+     * based on the provided promise.
+     *
+     * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.
+     * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type 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
@@ -152,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`.
@@ -182,24 +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
@@ -262,12 +214,24 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param errorFn when an error is thrown, this will wrap the error result if provided
      */
     static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: (e: any) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
+    /**
+     * Creates a new `Result` instance representing a successful operation.
+     *
+     * @param {T} value - The value to be wrapped in the `Result` instance.
+     * @return {Result<T, E>} A new `Result` instance with the provided value.
+     */
     static ok<T, E = never>(value: T): Result<T, E>;
+    /**
+     * Creates a new `Result` instance representing a successful operation with an undefined value.
+     *
+     * @return {Result<undefined, E>} A new `Result` instance with an undefined value.
+     */
+    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();
@@ -364,9 +328,9 @@ 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 no matter what the `Result` variant is.
+     * Performs a side effect for the `Ok` or `Err` variant of `Result`.
      *
      * @param fn The function to apply an `OK` value
      * @returns the result of applying `f` or an `Err` untouched
@@ -420,16 +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;
 /**
  * Evaluates the given generator to a Result returned or an Err yielded from it,
  * whichever comes first.
@@ -443,6 +404,7 @@ declare const fromThrowable: typeof Result.fromThrowable;
  * @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.
@@ -455,12 +417,94 @@ 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;
 }
-interface ResultarError<T, E> {
+interface ResultarError<T, E> extends Error {
     data: {
         type: string;
         value: T | undefined;
@@ -473,4 +517,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 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 };
+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

@@ -31,7 +31,9 @@ __export(src_exports, {
   ok: () => ok,
   okAsync: () => okAsync,
   safeTry: () => safeTry,
-  safeTryAsync: () => safeTryAsync
+  safeTryAsync: () => safeTryAsync,
+  unit: () => unit,
+  unitAsync: () => unitAsync
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -43,6 +45,7 @@ var createResultarError = (message, result, config = defaultErrorConfig) => {
   const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
   const maybeStack = config.withStackTrace ? new Error().stack : void 0;
   return {
+    name: "ResultarError",
     data,
     message,
     stack: maybeStack
@@ -50,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) {
@@ -65,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) {
@@ -84,6 +81,9 @@ var combineResultListWithAllErrors = (resultList) => {
   }
   return acc;
 };
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(
+  combineResultListWithAllErrors
+);
 
 // src/result.ts
 var Ok = class {
@@ -130,9 +130,23 @@ var Result = class _Result {
       }
     };
   }
+  /**
+   * Creates a new `Result` instance representing a successful operation.
+   *
+   * @param {T} value - The value to be wrapped in the `Result` instance.
+   * @return {Result<T, E>} A new `Result` instance with the provided value.
+   */
   static ok(value) {
     return new _Result(new Ok(value));
   }
+  /**
+   * Creates a new `Result` instance representing a successful operation with an undefined value.
+   *
+   * @return {Result<undefined, E>} A new `Result` instance with an undefined value.
+   */
+  static unit() {
+    return new _Result(new Ok(void 0));
+  }
   static err(error) {
     return new _Result(new Err(error));
   }
@@ -275,7 +289,7 @@ var Result = class _Result {
     return fnErr(this.error);
   }
   /**
-   * Performs a side effect no matter what the `Result` variant is.
+   * Performs a side effect for the `Ok` or `Err` variant of `Result`.
    *
    * @param fn The function to apply an `OK` value
    * @returns the result of applying `f` or an `Err` untouched
@@ -396,14 +410,14 @@ var DisposableResult = class {
     this.finalizer(this.result.value, this.result.error);
   }
 };
-var { ok, err, fromThrowable } = 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, err, fromThrowable, unit } = Result;
 
 // src/result-async.ts
 var DisposableResultAsync = class {
@@ -416,9 +430,29 @@ var DisposableResultAsync = class {
   }
 };
 var ResultAsync = class _ResultAsync {
+  /**
+   * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).
+   *
+   * @param {T} value - The value to be wrapped in a Result.ok.
+   * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.
+   */
   static okAsync(value) {
     return new _ResultAsync(Promise.resolve(Result.ok(value)));
   }
+  /**
+   * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
+   *
+   * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
+   */
+  static unitAsync() {
+    return new _ResultAsync(Promise.resolve(Result.unit()));
+  }
+  /**
+   * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).
+   *
+   * @param {E} error - The error to be wrapped in a Result.err.
+   * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.
+   */
   static errAsync(error) {
     return new _ResultAsync(Promise.resolve(Result.err(error)));
   }
@@ -523,8 +557,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));
@@ -613,8 +647,6 @@ var ResultAsync = class _ResultAsync {
     return yield* await this.innerPromise.then((res) => res.safeUnwrap());
   }
 };
-var { okAsync, errAsync, fromPromise, fromSafePromise } = ResultAsync;
-var fromThrowableAsync = ResultAsync.fromThrowable;
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -626,6 +658,8 @@ function safeTryAsync(body) {
     })()
   );
 }
+var { okAsync, errAsync, fromPromise, fromSafePromise, unitAsync } = ResultAsync;
+var fromThrowableAsync = ResultAsync.fromThrowable;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Result,
@@ -639,6 +673,8 @@ function safeTryAsync(body) {
   ok,
   okAsync,
   safeTry,
-  safeTryAsync
+  safeTryAsync,
+  unit,
+  unitAsync
 });
 //# sourceMappingURL=index.cjs.map