resultar 1.4.1 → 1.4.3

package/README.md

@@ -14,7 +14,7 @@ This package contains a `Result` type that represents either success (`Ok`) or f
 
 For asynchronous tasks, `resultar` offers a `ResultAsync` class which wraps a `Promise<Result<T, E>>` and gives you the same level of expressivity and control as a regular `Result<T, E>`.
 
-`ResultAsync` is `thenable` meaning it **behaves exactly like a native `Promise<Result>`** ... except you have access to the same methods that `Result` provides without having to `await` or `.then` the promise! 
+`ResultAsync` is `thenable` meaning it **behaves exactly like a native `Promise<Result>`** ... except you have access to the same methods that `Result` provides without having to `await` or `.then` the promise!
 
 ### Check out [the wiki](https://github.com/inaiat/resultar/wiki) for examples and best practices.
 
@@ -47,6 +47,7 @@ For asynchronous tasks, `resultar` offers a `ResultAsync` class which wraps a `P
     - [`Result.combine` (static class method)](#resultcombine-static-class-method)
     - [`Result.combineWithAllErrors` (static class method)](#resultcombinewithallerrors-static-class-method)
     - [`Result.safeUnwrap()`](#resultsafeunwrap)
+    - [`Result.tryCatch` (static class method)](#resulttrycatch-static-class-method)
   + [Asynchronous API (`ResultAsync`)](#asynchronous-api-resultasync)
     - [`okAsync`](#okasync)
     - [`errAsync`](#errasync)
@@ -66,12 +67,15 @@ For asynchronous tasks, `resultar` offers a `ResultAsync` class which wraps a `P
     - [`ResultAsync.combine` (static class method)](#resultasynccombine-static-class-method)
     - [`ResultAsync.combineWithAllErrors` (static class method)](#resultasynccombinewithallerrors-static-class-method)
     - [`ResultAsync.safeUnwrap()`](#resultasyncsafeunwrap)
+    - [`ResultAsync.tryCatch` (static class method)](#resultasynctrycatch-static-class-method)
   + [Utilities](#utilities)
     - [`fromThrowable`](#fromthrowable)
     - [`fromThrowableAsync`](#fromthrowableasync)
     - [`fromPromise`](#frompromise)
     - [`fromSafePromise`](#fromsafepromise)
     - [`safeTry`](#safetry)
+    - [`tryCatch`](#trycatch)
+    - [`tryCatchAsync`](#trycatchasync)
   + [Testing](#testing)
 * [A note on the Package Name](#a-note-on-the-package-name)
 
@@ -423,9 +427,9 @@ const updatedQueryResult = dbQueryResult.orElse((dbError) =>
     //
     // err() can be called with a value of any new type that you want
     // it could also be called with the same error value
-    //     
+    //
     //     err(dbError)
-    : err(500) 
+    : err(500)
 )
 ```
 
@@ -534,7 +538,7 @@ const asyncRes = parseHeaders(rawHeader)
 ```
 
 Note that in the above example if `parseHeaders` returns an `Err` then `.map` and `.asyncMap` will not be invoked, and `asyncRes` variable will resolve to an `Err` when turned into a `Result` using `await` or `.then()`.
-  
+
 [⬆️  Back to top](#toc)
 
 ---
@@ -667,6 +671,42 @@ const result = Result.combineWithAllErrors(resultList)
 
 Allows for unwrapping a `Result` or returning an `Err` implicitly, thereby reducing boilerplate.
 
+[⬆️  Back to top](#toc)
+
+#### `Result.tryCatch()` (static class method)
+
+Provides a convenient way to handle errors in a procedural style, similar to Go's error handling pattern. It wraps a synchronous function call in a try-catch block and returns a Result that can be destructured to access the value or error.
+
+**Signature:**
+```typescript
+static tryCatch<T, E>(fn: () => Exclude<T, Promise<any>>, errorFn?: (e: unknown) => E): Result<T, E>
+```
+
+**Example:**
+```typescript
+const divide = (a: number, b: number) => {
+  if (b === 0) throw new Error("Cannot divide by zero");
+  return a / b;
+};
+
+// Using destructuring to handle errors procedurally
+const { value, error } = Result.tryCatch(() => divide(10, 2));
+if (error) {
+  console.error("Division failed:", error);
+} else {
+  console.log("Result:", value); // Result: 5
+}
+
+// With custom error handling
+const result = Result.tryCatch(
+  () => divide(10, 0),
+  (e) => `Division error: ${e.message}`
+);
+if (result.isErr()) {
+  console.error(result.error); // Division error: Cannot divide by zero
+}
+```
+
 
 [⬆️  Back to top](#toc)
 
@@ -978,7 +1018,7 @@ usersInCanada.then((usersResult: Result<Array<User>, string>) => {
 
 #### `ResultAsync.unwrapOr` (method)
 
-Unwrap the `Ok` value, or return the default if there is an `Err`.  
+Unwrap the `Ok` value, or return the default if there is an `Err`.
 Works just like `Result.unwrapOr` but returns a `Promise<T>` instead of `T`.
 
 **Signature:**
@@ -1394,6 +1434,45 @@ Allows for unwrapping a `Result` or returning an `Err` implicitly, thereby reduc
 
 [⬆️  Back to top](#toc)
 
+#### `ResultAsync.tryCatch()` (static class method)
+
+Similar to `Result.tryCatch`, but for handling asynchronous operations. It wraps a Promise in a try-catch block and returns a ResultAsync that can be awaited and destructured to access the value or error.
+
+**Signature:**
+```typescript
+static tryCatch<T, E>(fn: Promise<T>, errorFn?: (e: unknown) => E): ResultAsync<T, E>
+```
+
+**Example:**
+```typescript
+const divideAsync = async (a: number, b: number) => {
+  await new Promise(resolve => setTimeout(resolve, 100)); // Simulate async operation
+  if (b === 0) throw new Error("Cannot divide by zero");
+  return a / b;
+};
+
+// Using async/await with destructuring
+const { value, error } = await ResultAsync.tryCatch(divideAsync(10, 2));
+if (error) {
+  console.error("Async division failed:", error);
+} else {
+  console.log("Result:", value); // Result: 5
+}
+
+// With custom error handling
+const result = await ResultAsync.tryCatch(
+  divideAsync(10, 0),
+  (e) => `Async division error: ${e.message}`
+);
+if (result.isErr()) {
+  console.error(result.error); // Async division error: Cannot divide by zero
+}
+```
+
+The `tryCatch` methods provide a more familiar error handling pattern for developers coming from languages like Go, while still maintaining the type safety and composability of the Result type.
+
+[⬆️  Back to top](#toc)
+
 ---
 
 ### Utilities
@@ -1423,10 +1502,28 @@ Please find documentation at [ResultAsync.fromPromise](#resultasyncfrompromise-s
 
 [⬆️  Back to top](#toc)
 
+---
+
+#### `tryCatch`
+
+Top level export of `Result.tryCatch`.
+Please find documentation at [Result.tryCatch](#resulttrycatch-static-class-method)
+
+[⬆️  Back to top](#toc)
+
+---
+
+#### `tryCatchAsync`
+
+Top level export of `ResultAsync.tryCatch`.
+Please find documentation at [ResultAsync.tryCatch](#resultasynctrycatch-static-class-method)
+
+[⬆️  Back to top](#toc)
+
 #### `fromSafePromise`
 
 Top level export of `ResultAsync.fromSafePromise`.
-Please find documentation at [ResultAsync.fromSafePromise](#resultasyncfromsafepromise-static-class-method)
+Please find documentation at [ResultAsync.fromSafePromise](#resulttasyncfromsafepromise-static-class-method)
 
 [⬆️  Back to top](#toc)
 

package/dist/{chunk-TU4HOJKA.js → chunk-ZA6ODIRF.js}

@@ -26,6 +26,25 @@ var Result = class _Result {
       this.value = void 0;
     }
   }
+  /**
+   * Creates a `Result` by running a function that might throw.
+   * If the function throws, the error will be caught and returned as an `Err`.
+   * If the function succeeds, the value will be wrapped in an `Ok`.
+   *
+   * @param fn - The function to execute, which might throw an error
+   * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`
+   * @returns A `Result` containing either the function's return value or the caught error
+   */
+  static tryCatch(fn, errorFn) {
+    try {
+      return ok(fn());
+    } catch (error) {
+      if (errorFn) {
+        return err(errorFn(error));
+      }
+      return err(error);
+    }
+  }
   /**
    * Wraps a function with a try catch, creating a new function with the same
    * arguments but returning `Ok` if successful, `Err` if the function throws
@@ -71,7 +90,9 @@ var Result = class _Result {
     return combineResultList(resultList);
   }
   static combineWithAllErrors(resultList) {
-    return combineResultListWithAllErrors(resultList);
+    return combineResultListWithAllErrors(
+      resultList
+    );
   }
   value;
   error;
@@ -285,7 +306,11 @@ var Result = class _Result {
    */
   _unsafeUnwrapErr(config) {
     if (this.state.ok) {
-      throw createResultarError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+      throw createResultarError(
+        "Called `_unsafeUnwrapErr` on an Ok",
+        this,
+        config
+      );
     }
     return this.error;
   }
@@ -352,6 +377,7 @@ var ok = Result.ok;
 var err = Result.err;
 var fromThrowable = Result.fromThrowable;
 var unit = Result.unit;
+var tryCatch = Result.tryCatch;
 
 // src/result-async.ts
 var DisposableResultAsync = class {
@@ -390,6 +416,36 @@ var ResultAsync = class _ResultAsync {
   static errAsync(error) {
     return new _ResultAsync(Promise.resolve(Result.err(error)));
   }
+  /**
+   * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.
+   *
+   * @param fn - The Promise to be wrapped in a ResultAsync.
+   * @param errorFn - Optional function to transform the caught error into a specific error type.
+   *                  If not provided, the original error will be used.
+   * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,
+   *          or Err with either the transformed error (if errorFn is provided) or the original error.
+   *
+   * @example
+   * ```typescript
+   * // Without error transformer
+   * const result = ResultAsync.tryCatch(Promise.resolve(42));
+   *
+   * // With error transformer
+   * const result = ResultAsync.tryCatch(
+   *   fetch('https://api.example.com'),
+   *   (error) => new CustomError('API request failed')
+   * );
+   * ```
+   */
+  static tryCatch(fn, errorFn) {
+    const newPromise = fn.then((value) => Result.ok(value)).catch((error) => {
+      if (errorFn) {
+        return Result.err(errorFn(error));
+      }
+      return Result.err(error);
+    });
+    return new _ResultAsync(newPromise);
+  }
   static fromSafePromise(promise) {
     const newPromise = promise.then((value) => Result.ok(value));
     return new _ResultAsync(newPromise);
@@ -617,6 +673,7 @@ var fromPromise = ResultAsync.fromPromise;
 var fromSafePromise = ResultAsync.fromSafePromise;
 var unitAsync = ResultAsync.unitAsync;
 var fromThrowableAsync = ResultAsync.fromThrowable;
+var tryCatchAsync = ResultAsync.tryCatch;
 
 // src/utils.ts
 var combineResultList = (resultList) => {
@@ -663,6 +720,7 @@ export {
   err,
   fromThrowable,
   unit,
+  tryCatch,
   DisposableResultAsync,
   ResultAsync,
   safeTryAsync,
@@ -671,6 +729,7 @@ export {
   fromPromise,
   fromSafePromise,
   unitAsync,
-  fromThrowableAsync
+  fromThrowableAsync,
+  tryCatchAsync
 };
-//# sourceMappingURL=chunk-TU4HOJKA.js.map
+//# sourceMappingURL=chunk-ZA6ODIRF.js.map

package/dist/chunk-ZA6ODIRF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/result.ts","../src/result-async.ts","../src/utils.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/unbound-method */\nimport type { ErrorConfig } from './error.js'\nimport { createResultarError } from './error.js'\nimport { errAsync, ResultAsync } from './result-async.js'\nimport type { ExtractErrTypes, ExtractOkTypes, InferErrTypes, InferOkTypes } from './utils.js'\nimport { combineResultList, combineResultListWithAllErrors } from './utils.js'\nclass Ok<T> {\n  readonly ok = true\n  constructor(public readonly value: T) {}\n}\n\nclass Err<E> {\n  readonly ok = false\n  constructor(public readonly error: E) {}\n}\n\n/**\n * A Result interface that is used to define the methods that are available on a\n * `Result` object.\n *\n * The immutability of the `Result` object is maintained by the interface.\n */\ninterface Resultable<T, E> {\n  get value(): T\n  get error(): E\n\n  /**\n   * Used to check if a `Result` is an `OK`\n   *\n   * @returns `true` if the result is an `OK` variant of Result\n   */\n  isOk(): boolean\n\n  /**\n   * Used to check if a `Result` is an `Err`\n   *\n   * @returns `true` if the result is an `Err` variant of Result\n   */\n  isErr(): boolean\n  /**\n   * Unwrap the `Ok` value, or return the default if there is an `Err`\n   *\n   * @param v the default value to return if there is an `Err`\n   */\n\n  unwrapOr<A>(defaultValue: A): T | A\n\n  // safeUnwrap(): Generator<Result<never, E>, T>\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrap(config?: ErrorConfig): T\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,\n   * otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrapErr(config?: ErrorConfig): E\n}\n\n/**\n * A `Result` is a type that represents either success (`Ok`) or failure (`Err`).\n * It is often used to replace exceptions or `null` returns.\n * `Result` is often used to handle errors in a functional way.\n * The `Result` type is often used to handle errors in a functional way.\n */\nexport class Result<T, E> implements Resultable<T, E> {\n  /**\n   * Creates a `Result` by running a function that might throw.\n   * If the function throws, the error will be caught and returned as an `Err`.\n   * If the function succeeds, the value will be wrapped in an `Ok`.\n   *\n   * @param fn - The function to execute, which might throw an error\n   * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`\n   * @returns A `Result` containing either the function's return value or the caught error\n   */\n  static tryCatch<T, E>(\n    fn: () => Exclude<T, Promise<unknown>>,\n    errorFn?: (e: unknown) => E,\n  ): Result<T, E> {\n    try {\n      return ok(fn())\n    } catch (error) {\n      if (errorFn) {\n        return err(errorFn(error))\n      }\n      return err(error as E)\n    }\n  }\n\n  /**\n   * Wraps a function with a try catch, creating a new function with the same\n   * arguments but returning `Ok` if successful, `Err` if the function throws\n   *\n   * @param fn function to wrap with ok on success or err on failure\n   * @param errorFn when an error is thrown, this will wrap the error result if provided\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(\n    fn: Fn,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    errorFn?: (e: any) => E,\n  ): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E> {\n    return (...args) => {\n      try {\n        const result = fn(...args)\n        return ok(result as ReturnType<Fn>)\n      } catch (error) {\n        if (errorFn) {\n          return err(errorFn(error))\n        }\n\n        return err(error as E)\n      }\n    }\n  }\n\n  /**\n   * Creates a new `Result` instance representing a successful operation.\n   *\n   * @param {T} value - The value to be wrapped in the `Result` instance.\n   * @return {Result<T, E>} A new `Result` instance with the provided value.\n   */\n  static ok<T, E = never>(value: T): Result<T, E> {\n    return new Result<T, E>(new Ok(value))\n  }\n\n  /**\n   * Creates a new `Result` instance representing a successful operation with an undefined value.\n   *\n   * @return {Result<undefined, E>} A new `Result` instance with an undefined value.\n   */\n  static unit<E = never>(): Result<undefined, E> {\n    return new Result<undefined, E>(new Ok(undefined))\n  }\n\n  static err<T = never, E = unknown>(error: E): Result<T, E> {\n    return new Result<T, E>(new Err(error))\n  }\n\n  static combine<\n    T extends readonly [\n      Result<unknown, unknown>,\n      ...Result<unknown, unknown>[],\n    ],\n  >(resultList: T): CombineResults<T>\n  static combine<T extends readonly Result<unknown, unknown>[]>(\n    resultList: T,\n  ): CombineResults<T>\n  static combine<\n    T extends readonly [\n      Result<unknown, unknown>,\n      ...Result<unknown, unknown>[],\n    ],\n  >(resultList: T): CombineResults<T> {\n    return combineResultList(resultList) as CombineResults<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [\n      Result<unknown, unknown>,\n      ...Result<unknown, unknown>[],\n    ],\n  >(resultList: T): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T> {\n    return combineResultListWithAllErrors(\n      resultList,\n    ) as CombineResultsWithAllErrorsArray<T>\n  }\n\n  readonly value: T\n  readonly error: E\n\n  private constructor(private readonly state: Ok<T> | Err<E>) {\n    if (state.ok) {\n      this.value = state.value\n      this.error = undefined as E\n    } else {\n      this.error = state.error\n      this.value = undefined as T\n    }\n  }\n\n  /**\n   * Used to check if a `Result` is an `OK`\n   *\n   * @returns `true` if the result is an `OK` variant of Result\n   */\n  isOk(): boolean {\n    return this.state.ok\n  }\n\n  /**\n   * Used to check if a `Result` is an `Err`\n   *\n   * @returns `true` if the result is an `Err` variant of Result\n   */\n  isErr(): boolean {\n    return !this.state.ok\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<U, E>`\n   * by applying a function to a contained `Ok` value, leaving an `Err` value\n   * untouched.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  map<X>(f: (t: T) => X): Result<X, E> {\n    if (this.state.ok) {\n      const value = f(this.value)\n      return ok(value)\n    }\n\n    return err(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a\n   * contained `Err` value, leaving an `Ok` value untouched.\n   *\n   * This function can be used to pass through a successful result while\n   * handling an error.\n   *\n   * @param f a function to apply to the error `Err` value\n   */\n  mapErr<X>(fn: (t: E) => X): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value)\n    }\n\n    return err(fn(this.error))\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent computation using the\n   * inner `T` value, but that computation might fail.\n   * Additionally, `andThen` is really useful as a tool to flatten a\n   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).\n   *\n   * @param f The function to apply to the current value\n   */\n  andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error)\n  }\n\n  if(fCondition: (t: T) => boolean): {\n    true: <X1, Y1>(fTrue: (t: T) => Result<X1, Y1>) => {\n      false: <X2, Y2>(\n        fFalse: (t: T) => Result<X2, Y2>,\n      ) => Result<X1 | X2, Y1 | Y2 | E>\n    }\n  } {\n    return {\n      true: <X1, Y1>(fTrue: (t: T) => Result<X1, Y1>) => ({\n        false: <X2, Y2>(\n          fFalse: (t: T) => Result<X2, Y2>,\n        ): Result<X1 | X2, Y1 | Y2 | E> => {\n          if (this.state.ok) {\n            const condition = fCondition(this.value)\n            return condition ? fTrue(this.value) : fFalse(this.value)\n          }\n\n          return err(this.error)\n        },\n      }),\n    }\n  }\n\n  /**\n   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.\n   *\n   * This is useful for error recovery.\n   *\n   * @param f  A function to apply to an `Err` value, leaving `Ok` values\n   * untouched.\n   */\n  orElse<R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ): Result<InferOkTypes<R> | T, InferErrTypes<R>>\n  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A> {\n    if (this.state.ok) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return f(this.error)\n  }\n\n  /**\n   * Similar to `map` Except you must return a new `Result`.\n   *\n   * This is useful for when you need to do a subsequent async computation using\n   * the inner `T` value, but that computation might fail. Must return a ResultAsync\n   *\n   * @param f The function that returns a `ResultAsync` to apply to the current\n   * value\n   */\n  asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return errAsync(this.error)\n  }\n\n  /**\n   * Maps a `Result<T, E>` to `ResultAsync<U, E>`\n   * by applying an async function to a contained `Ok` value, leaving an `Err`\n   * value untouched.\n   *\n   * @param f An async function to apply an `OK` value\n   */\n  asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E> {\n    if (this.state.ok) {\n      return ResultAsync.fromSafePromise(f(this.value))\n    }\n\n    return errAsync(this.error)\n  }\n\n  /**\n   * Unwrap the `Ok` value, or return the default if there is an `Err`\n   *\n   * @param v the default value to return if there is an `Err`\n   */\n  unwrapOr<A>(defaultValue: A): T | A {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    return defaultValue\n  }\n\n  /**\n   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)\n   * execute the function that matches the `Result` variant.\n   *\n   * Match callbacks do not necessitate to return a `Result`, however you can\n   * return a `Result` if you want to.\n   *\n   * `match` is like chaining `map` and `mapErr`, with the distinction that\n   * with `match` both functions must have the same return type.\n   *\n   * @param ok\n   * @param err\n   */\n  match<A, B = A>(fnOk: (t: T) => A, fnErr: (e: E) => B): A | B {\n    if (this.state.ok) {\n      return fnOk(this.value)\n    }\n\n    return fnErr(this.error)\n  }\n\n  /**\n   * Performs a side effect for the `Ok` or `Err` variant of `Result`.\n   *\n   * @param fn The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  log(fn: (t?: T, e?: E) => void): this {\n    try {\n      fn(this.value, this.error)\n    } catch { /* empty */ }\n\n    return this\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `Result`.\n   *\n   * @param fn The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  tap(fn: (t: T) => void): this {\n    if (this.state.ok) {\n      try {\n        fn(this.value)\n      } catch { /* empty */ }\n    }\n\n    return this\n  }\n\n  /**\n   * Performs a side effect for the `Err` variant of `Result`.\n   *\n   * @param fn The function to apply an `Err` value\n   * @returns the result of applying `f` or an `Ok` untouched\n   */\n  tapError(fn: (e: E) => void): this {\n    if (!this.state.ok) {\n      try {\n        fn(this.error)\n      } catch { /* empty */ }\n    }\n\n    return this\n  }\n\n  /**\n   * This method is used to clean up and release any resources that the `Result`\n   * @param f The function that will be called to clean up the resources\n   */\n  finally<X = T, Y = E>(\n    f: (value: X, error: Y) => void,\n  ): DisposableResult<X, Y>\n  finally(f: (value: T, error: E) => void): DisposableResult<T, E> {\n    const resultDisposable = new DisposableResult(this, f)\n    try {\n      return resultDisposable\n    } finally {\n      resultDisposable[Symbol.dispose]()\n    }\n  }\n\n  unwrapOrThrow(): T {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    // eslint-disable-next-line @typescript-eslint/only-throw-error\n    throw this.error\n  }\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrap(config?: ErrorConfig): T {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    throw createResultarError('Called `_unsafeUnwrap` on an Err', this, config)\n  }\n\n  /**\n   * **This method is unsafe, and should only be used in a test environments**\n   *\n   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,\n   * otherwise it throws a custom object.\n   *\n   * @param config\n   */\n  _unsafeUnwrapErr(config?: ErrorConfig): E {\n    if (this.state.ok) {\n      throw createResultarError(\n        'Called `_unsafeUnwrapErr` on an Ok',\n        this,\n        config,\n      )\n    }\n\n    return this.error\n  }\n\n  *[Symbol.iterator](): Generator<Result<never, E>, T> {\n    if (this.state.ok) {\n      return this.value\n    }\n\n    // eslint-disable-next-line unicorn/no-this-assignment, @typescript-eslint/no-this-alias\n    const self: Result<T, E> = this\n    yield self as Result<never, E>\n    return self as T\n  }\n\n  safeUnwrap(): Generator<Result<never, E>, T> {\n    if (this.state.ok) {\n      const { value } = this\n      /* eslint-disable-next-line require-yield */\n      return (function*() {\n        return value\n      })()\n    }\n\n    const { error } = this\n    return (function*() {\n      yield err(error)\n\n      throw new Error('Do not use this generator out of `safeTry`')\n    })()\n  }\n}\n\n/**\n * A `Disposable` is an object that has a `dispose` method that can be used to\n * clean up resources.\n */\nexport class DisposableResult<T, E> implements Resultable<T, E>, Disposable {\n  constructor(\n    readonly result: Resultable<T, E>,\n    private readonly finalizer: (value: T, error: E) => void,\n  ) {}\n\n  get value(): T {\n    return this.result.value\n  }\n\n  get error(): E {\n    return this.result.error\n  }\n\n  _unsafeUnwrap(config?: ErrorConfig): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  _unsafeUnwrapErr(config?: ErrorConfig): E {\n    return this.result._unsafeUnwrapErr(config)\n  }\n\n  isOk(): boolean {\n    return this.result.isOk()\n  }\n\n  isErr(): boolean {\n    return this.result.isErr()\n  }\n\n  unwrapOr<A>(defaultValue: A): T | A {\n    return this.result.unwrapOr(defaultValue)\n  }\n\n  [Symbol.dispose](): void {\n    this.finalizer(this.result.value, this.result.error)\n  }\n}\n\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` works as\n * Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\nexport function safeTry<T, E>(\n  body: () => Generator<Result<never, E>, Result<T, E>>,\n): Result<T, E>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n  body: () => Generator<YieldErr, GeneratorReturnResult>,\n): Result<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\n\n/**\n * Evaluates the given generator to a Result returned or an Err yielded from it,\n * whichever comes first.\n *\n * This function, in combination with `Result.safeUnwrap()`, is intended to emulate\n * Rust's ? operator.\n * See `/tests/safeTry.test.ts` for examples.\n *\n * @param body - What is evaluated. In body, `yield* result.safeUnwrap()` and\n * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.\n * @returns The first occurence of either an yielded Err or a returned Result.\n */\nexport function safeTry<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E>\nexport function safeTry<\n  YieldErr extends Result<never, unknown>,\n  GeneratorReturnResult extends Result<unknown, unknown>,\n>(\n  body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>,\n): ResultAsync<\n  InferOkTypes<GeneratorReturnResult>,\n  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>\n>\nexport function safeTry<T, E>(\n  body:\n    | (() => Generator<Result<never, E>, Result<T, E>>)\n    | (() => AsyncGenerator<Result<never, E>, Result<T, E>>),\n): Result<T, E> | ResultAsync<T, E> {\n  const n = body().next()\n  if (n instanceof Promise) {\n    return new ResultAsync(n.then((r) => r.value))\n  }\n\n  return n.value\n}\n\nexport const ok = Result.ok\nexport const err = Result.err\nexport const fromThrowable = Result.fromThrowable\nexport const unit = Result.unit\nexport const tryCatch = Result.tryCatch\n\n// #region Combine - Types\n\n// This is a helper type to prevent infinite recursion in typing rules.\n//\n// Use this with your `depth` variable in your types.\ntype Prev = [\n  never,\n  0,\n  1,\n  2,\n  3,\n  4,\n  5,\n  6,\n  7,\n  8,\n  9,\n  10,\n  11,\n  12,\n  13,\n  14,\n  15,\n  16,\n  17,\n  18,\n  19,\n  20,\n  21,\n  22,\n  23,\n  24,\n  25,\n  26,\n  27,\n  28,\n  29,\n  30,\n  31,\n  32,\n  33,\n  34,\n  35,\n  36,\n  37,\n  38,\n  39,\n  40,\n  41,\n  42,\n  43,\n  44,\n  45,\n  46,\n  47,\n  48,\n  49,\n  ...0[],\n]\n\n// Collects the results array into separate tuple array.\n//\n// T         - The array of the results\n// Collected - The collected tuples.\n// Depth     - The maximum depth.\ntype CollectResults<\n  T,\n  Collected extends unknown[] = [],\n  Depth extends number = 50,\n> = [\n  Depth,\n] extends [never] ? []\n  : T extends [infer H, ...infer Rest]\n  // And test whether the head of the list is a result\n    ? H extends Result<infer L, infer R>\n      // Continue collecting...\n      ? CollectResults<\n        // the rest of the elements\n        Rest,\n        // The collected\n        [...Collected, [L, R]],\n        // and one less of the current depth\n        Prev[Depth]\n      >\n    : never // Impossible\n  : Collected\n\n// Transposes an array\n//\n// A          - The array source\n// Transposed - The collected transposed array\n// Depth      - The maximum depth.\nexport type Transpose<\n  A,\n  Transposed extends unknown[][] = [],\n  Depth extends number = 10,\n> = A extends [infer T, ...infer Rest]\n  ? T extends [infer L, infer R]\n    ? Transposed extends [infer PL, infer PR]\n      ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]>\n        : never\n      : never\n    : Transpose<Rest, [[L], [R]], Prev[Depth]>\n  : Transposed\n  : Transposed\n\n// Combines the both sides of the array of the results into a tuple of the\n// union of the ok types and the union of the err types.\n//\n// T     - The array of the results\n// Depth - The maximum depth.\nexport type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [\n  infer L,\n  infer R,\n] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n  : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []]\n  : never\n\n// Deduplicates the result, as the result type is a union of Err and Ok types.\nexport type Dedup<T> = T extends Result<infer RL, infer RR> ? Result<RL, RR>\n  : T\n\n// Given a union, this gives the array of the union members.\nexport type MemberListOf<T> = (\n  (T extends unknown ? (t: T) => T : never) extends infer U\n    ? (U extends unknown ? (u: U) => unknown : never) extends (v: infer V) => unknown ? V\n    : never\n    : never\n) extends (_: unknown) => infer W ? [...MemberListOf<Exclude<T, W>>, W]\n  : []\n\n// Converts an empty array to never.\n//\n// The second type parameter here will affect how to behave to `never[]`s.\n// If a precise type is required, pass `1` here so that it will resolve\n// a literal array such as `[ never, never ]`. Otherwise, set `0` or the default\n// type value will cause this to resolve the arrays containing only `never`\n// items as `never` only.\nexport type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never\n  : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never\n      : T\n    : T\n  : T\n\n// Converts the `unknown` items of an array to `never`s.\ntype UnknownMembersToNever<T> = T extends [infer H, ...infer R]\n  ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>]\n  : T\n\n// Gets the member type of the array or never.\nexport type MembersToUnion<T> = T extends unknown[] ? T[number] : never\n\n// Checks if the given type is a literal array.\nexport type IsLiteralArray<T> = T extends { length: infer L } ? L extends number ? number extends L ? 0\n    : 1\n  : 0\n  : 0\n\n// Traverses an array of results and returns a single result containing\n// the oks and errs union-ed/combined.\ntype Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs]\n  ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>>\n  : never\n\n// Traverses an array of results and returns a single result containing\n// the oks combined and the array of errors combined.\ntype TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<\n  infer Oks,\n  infer Errs\n> ? Result<Oks, Errs[]>\n  : never\n\n// Combines the array of results into one result.\nexport type CombineResults<\n  T extends readonly Result<unknown, unknown>[],\n> = IsLiteralArray<T> extends 1 ? Traverse<T>\n  : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>\n\n// Combines the array of results into one result with all errors.\nexport type CombineResultsWithAllErrorsArray<\n  T extends readonly Result<unknown, unknown>[],\n> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T>\n  : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>\n\n// #endregion\n","/* eslint-disable @typescript-eslint/unbound-method */\nimport type { Combine, Dedup, EmptyArrayToNever, IsLiteralArray, MemberListOf, MembersToUnion } from './result.js'\nimport { Result } from './result.js'\nimport type {\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes,\n  InferAsyncOkTypes,\n  InferErrTypes,\n  InferOkTypes,\n} from './utils.js'\nimport { combineResultAsyncList, combineResultAsyncListWithAllErrors } from './utils.js'\n\nexport class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  private readonly innerPromise: Promise<Result<T, E>>\n\n  constructor(res: Promise<Result<T, E>>) {\n    this.innerPromise = res\n  }\n\n  then<A, B>( // eslint-disable-line unicorn/no-thenable\n    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,\n    failureCallback?: (reason: unknown) => B | PromiseLike<B>,\n  ): PromiseLike<A | B> {\n    return this.innerPromise.then(successCallback, failureCallback)\n  }\n}\n\n/**\n * Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.\n * This class provides a way to handle asynchronous operations that may succeed with a value of type T\n * or fail with an error of type E.\n *\n * @template T - The type of the success value\n * @template E - The type of the error value\n *\n * @implements {PromiseLike<Result<T, E>>}\n *\n * @example\n * ```typescript\n * // Create a successful async result\n * const okAsync = ResultAsync.okAsync(42);\n *\n * // Create a failed async result\n * const errAsync = ResultAsync.errAsync(new Error(\"Something went wrong\"));\n *\n * // Transform a Promise into a ResultAsync\n * const resultFromPromise = ResultAsync.fromPromise(\n *   fetch(\"https://api.example.com/data\"),\n *   (error) => new Error(`API call failed: ${error}`)\n * );\n * ```\n *\n * @remarks\n * ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.\n * It provides various utility methods for transforming and combining results, similar to the Result type,\n * but operating in an asynchronous context.\n *\n * The class includes methods for:\n * - Creating ResultAsync instances (okAsync, errAsync, fromPromise)\n * - Transforming values (map, mapErr)\n * - Chaining operations (andThen, orElse)\n * - Error handling (tapError)\n * - Conditional branching (if)\n * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)\n */\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\n  /**\n   * Returns a ResultAsync instance that is immediately resolved with a Result.ok(value).\n   *\n   * @param {T} value - The value to be wrapped in a Result.ok.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given value and error type E.\n   */\n  static okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(Result.ok(value)))\n  }\n\n  /**\n   * Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.\n   *\n   * @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.\n   */\n  static unitAsync<E = never>(): ResultAsync<undefined, E> {\n    return new ResultAsync<undefined, E>(Promise.resolve(Result.unit()))\n  }\n\n  /**\n   * Returns a ResultAsync instance that is immediately resolved with a Result.err(error).\n   *\n   * @param {E} error - The error to be wrapped in a Result.err.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given error and value type T.\n   */\n  static errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E> {\n    return new ResultAsync<T, E>(Promise.resolve(Result.err(error)))\n  }\n\n  /**\n   * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.\n   *\n   * @param fn - The Promise to be wrapped in a ResultAsync.\n   * @param errorFn - Optional function to transform the caught error into a specific error type.\n   *                  If not provided, the original error will be used.\n   * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,\n   *          or Err with either the transformed error (if errorFn is provided) or the original error.\n   *\n   * @example\n   * ```typescript\n   * // Without error transformer\n   * const result = ResultAsync.tryCatch(Promise.resolve(42));\n   *\n   * // With error transformer\n   * const result = ResultAsync.tryCatch(\n   *   fetch('https://api.example.com'),\n   *   (error) => new CustomError('API request failed')\n   * );\n   * ```\n   */\n  static tryCatch<T, E>(fn: Promise<T>, errorFn?: (e: unknown) => E): ResultAsync<T, E> {\n    const newPromise = fn\n      .then((value: T) => Result.ok(value))\n      .catch(error => {\n        if (errorFn) {\n          return Result.err(errorFn(error))\n        }\n        return Result.err(error)\n      })\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  /**\n   * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)\n   * based on the provided promise.\n   *\n   * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\n   */\n  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>\n  static fromSafePromise<T, E = never>(promise: Promise<T>): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  /**\n   * Returns a ResultAsync instance that is resolved with a Result.ok(value) or Result.err(error)\n   * based on the provided promise.\n   *\n   * @param {Promise<T>} promise - The promise to be wrapped in a ResultAsync.\n   * @param {(e: unknown) => E} errorFn - A function that transforms the error from the promise into the error type E.\n   * @return {ResultAsync<T, E>} A ResultAsync instance with the given promise and error type E.\n   */\n  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>\n  static fromPromise<T, E>(promise: Promise<T>, errorFn: (e: unknown) => E): ResultAsync<T, E> {\n    const newPromise = promise\n      .then((value: T) => Result.ok(value))\n      .catch(error => Result.err(errorFn(error)))\n\n    return new ResultAsync<T, E>(newPromise)\n  }\n\n  static combine<\n    T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n  >(asyncResultList: T): CombineResultAsyncs<T>\n  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T> {\n    return (combineResultAsyncList(asyncResultList) as unknown) as CombineResultAsyncs<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]],\n  >(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T> {\n    return combineResultAsyncListWithAllErrors(\n      asyncResultList,\n    ) as CombineResultsWithAllErrorsArrayAsync<T>\n  }\n\n  /**\n   * Wraps a async function with a try catch, creating a new function with the same\n   * arguments but returning `Ok` if successful, `Err` if the function throws\n   *\n   * @param fn function to wrap with ok on success or err on failure\n   * @param errorFn when an error is thrown, this will wrap the error result if provided\n   * @returns a new function that returns a `ResultAsync`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static fromThrowable<A extends readonly any[], T, E>(\n    fn: (...args: A) => Promise<T>,\n    errorFn?: (err: unknown) => E,\n  ): (...args: A) => ResultAsync<T, E> {\n    return (...args) =>\n      new ResultAsync<T, E>(\n        (async () => {\n          try {\n            const v = await fn(...args)\n            return Result.ok(v)\n          } catch (error) {\n            const e = errorFn ? errorFn(error) : error\n            return Result.err(e as E)\n          }\n        })(),\n      )\n  }\n\n  private readonly innerPromise: Promise<Result<T, E>>\n\n  constructor(res: Promise<Result<T, E>>) {\n    this.innerPromise = res\n  }\n\n  then<A, B>( // eslint-disable-line unicorn/no-thenable\n    successCallback?: (res: Result<T, E>) => A | PromiseLike<A>,\n    failureCallback?: (reason: unknown) => B | PromiseLike<B>,\n  ): PromiseLike<A | B> {\n    return this.innerPromise.then(successCallback, failureCallback)\n  }\n\n  mapErr<U>(f: (t: E) => U | Promise<U>): ResultAsync<T, U> {\n    return new ResultAsync<T, U>(this.innerPromise.then(async res => {\n      if (res.isOk()) {\n        return okAsync(res.value)\n      }\n\n      return errAsync(await f(res.error))\n    }))\n  }\n\n  map<X>(f: (t: T) => X | Promise<X>): ResultAsync<X, E> {\n    const x = new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        return okAsync(await f(res.value))\n      }),\n    )\n\n    return x\n  }\n\n  andThen<R extends Result<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>\n  andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  andThen(f: any): any {\n    return new ResultAsync(\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n        const newValue = f(res.value) // eslint-disable-line @typescript-eslint/no-unsafe-assignment\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue // eslint-disable-line @typescript-eslint/no-unsafe-return\n      }),\n    )\n  }\n\n  if(fCondition: (t: T) => boolean): {\n    true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => {\n      false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>) => ResultAsync<X1 | X2, Y1 | Y2 | E>\n    }\n  } {\n    return {\n      true: <X1, Y1>(fTrue: (t: T) => ResultAsync<X1, Y1>) => ({\n        false: <X2, Y2>(fFalse: (t: T) => ResultAsync<X2, Y2>): ResultAsync<X1 | X2, Y1 | Y2 | E> =>\n          new ResultAsync(this.innerPromise.then(async res => {\n            if (res.isOk()) {\n              const condition = fCondition(res.value)\n              return condition ? fTrue(res.value) : fFalse(res.value)\n            }\n\n            return errAsync(res.error)\n          })),\n      }),\n    }\n  }\n\n  orElse<R extends Result<unknown, unknown>>(\n    f: (e: E) => R,\n  ): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>\n  orElse<R extends ResultAsync<unknown, unknown>>(\n    f: (e: E) => R,\n  ): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>\n  orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  orElse(f: any): any {\n    return new ResultAsync(\n      this.innerPromise.then(async (res: Result<T, E>) => { // eslint-disable-line @typescript-eslint/no-unsafe-argument\n        if (res.isErr()) {\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n          return f(res.error) // eslint-disable-line @typescript-eslint/no-unsafe-return\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  async match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B> {\n    return this.innerPromise.then(res => res.match(ok, fnErr))\n  }\n\n  async unwrapOr<A>(t: A): Promise<T | A> {\n    return this.innerPromise.then(res => res.unwrapOr(t))\n  }\n\n  async unwrapOrThrow(): Promise<T> {\n    return this.innerPromise.then(res => res.unwrapOrThrow())\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `ResultAsync`.\n   * This function can be used for control flow based on result values.\n   * @param f The function to call if the result is `Ok`\n   * @returns `self` if the result is `Err`, otherwise the result of `f`\n   */\n  log(f: (t?: T, e?: E) => void | Promise<void>): ResultAsync<T, E> {\n    return new ResultAsync(\n      this.innerPromise.then(async res => {\n        if (res.isOk()) {\n          try {\n            await f(res.value)\n          } catch { /* empty */ }\n\n          return okAsync(res.value)\n        }\n\n        try {\n          await f(undefined, res.error)\n        } catch { /* empty */ }\n\n        return errAsync(res.error)\n      }),\n    )\n  }\n\n  /**\n   * Performs a side effect for the `Ok` variant of `ResultAsync`.\n   * This function can be used for control flow based on result values.\n   * @param f The function to call if the result is `Ok`\n   * @returns `self` if the result is `Err`, otherwise the result of `f`\n   */\n  tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E> {\n    return new ResultAsync(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        try {\n          await f(res.value)\n        } catch { /* empty */ }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  /**\n   * Performs a side effect for the `Err` variant of `ResultAsync`.\n   * This function can be used for control flow based on result values.\n   * @param f The function to call if the result is `Err`\n   * @returns `self` if the result is `Ok`, otherwise the result of `f`\n   * @example\n   */\n  tapError(f: (e: E) => void | Promise<void>): ResultAsync<T, E> {\n    return new ResultAsync(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          try {\n            await f(res.error)\n          } catch { /* empty */ }\n\n          return errAsync(res.error)\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\n\n  finally(f: (value: T, error: E) => void): DisposableResultAsync<T, E> {\n    return new DisposableResultAsync(\n      // eslint-disable-next-line @typescript-eslint/require-await\n      this.innerPromise.then(async res => {\n        try {\n          res.finally(f)\n        } catch {\n          // Dont do anything. Its just a finally\n        }\n\n        return res\n      }),\n    )\n  }\n\n  async *[Symbol.asyncIterator](): AsyncGenerator<Result<never, E>, T> {\n    const result = await this.innerPromise\n\n    if (result.isErr()) {\n      yield errAsync(result.error)\n    }\n\n    return result.value\n  }\n\n  /**\n   * @deprecated will be removed in 2.0.0.\n   *\n   * You can use `safeTry` without this method.\n   * @example\n   * ```typescript\n   * safeTry(async function* () {\n   *   const okValue = yield* yourResult\n   * })\n   * ```\n   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.\n   */\n  async *safeUnwrap(): AsyncGenerator<Result<never, E>, T> {\n    return yield* await this.innerPromise.then(res => res.safeUnwrap())\n  }\n}\n\n/**\n * @deprecated Use `safeTry` instead.\n * @see `safeTry`\n *\n * This will be removed in the next major version.\n */\nexport function safeTryAsync<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(\n    (async () => {\n      const n = await body().next()\n      if (n.value.isOk()) {\n        return okAsync(n.value.value)\n      }\n\n      return errAsync(n.value.error)\n    })(),\n  )\n}\n\nexport const okAsync = ResultAsync.okAsync\nexport const errAsync = ResultAsync.errAsync\nexport const fromPromise = ResultAsync.fromPromise\nexport const fromSafePromise = ResultAsync.fromSafePromise\nexport const unitAsync = ResultAsync.unitAsync\nexport const fromThrowableAsync = ResultAsync.fromThrowable\nexport const tryCatchAsync = ResultAsync.tryCatch\n\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<\n  T extends readonly ResultAsync<unknown, unknown>[],\n> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>\n\n// Combines the array of async results into one result with all errors.\nexport type CombineResultsWithAllErrorsArrayAsync<\n  T extends readonly ResultAsync<unknown, unknown>[],\n> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>\n\n// Unwraps the inner `Result` from a `ResultAsync` for all elements.\ntype UnwrapAsync<T> = IsLiteralArray<T> extends 1\n  ? Writable<T> extends [infer H, ...infer Rest]\n    ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>]\n      : never\n    : never\n  : []\n  // If we got something too general such as ResultAsync<X, Y>[] then we\n  // simply need to map it to ResultAsync<X[], Y[]>. Yet `ResultAsync`\n  // itself is a union therefore it would be enough to cast it to Ok.\n  : T extends (infer A)[] ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Result<L, R>[]\n      : never\n    : never\n  : never\n\n// Traverse through the tuples of the async results and create one\n// `ResultAsync` where the collected tuples are merged.\ntype TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1\n  ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>>\n  : never\n  // The following check is important if we somehow reach to the point of\n  // checking something similar to ResultAsync<X, Y>[]. In this case we don't\n  // know the length of the elements, therefore we need to traverse the X and Y\n  // in a way that the result should contain X[] and Y[].\n  : T extends (infer I)[]\n  // The MemberListOf<I> here is to include all possible types. Therefore\n  // if we face (ResultAsync<X, Y> | ResultAsync<A, B>)[] this type should\n  // handle the case.\n    ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n      // The following `extends unknown[]` checks are just to satisfy the TS.\n      // we already expect them to be an array.\n      ? Oks extends unknown[]\n        ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>>\n        : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs>\n        // The rest of the conditions are to satisfy the TS and support\n        // the edge cases which are not really expected to happen.\n      : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>>\n      : ResultAsync<Oks, Errs>\n    : never\n  : never\n\n// This type is similar to the `TraverseAsync` while the errors are also\n// collected in a list. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<\n  T,\n  Depth\n> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]>\n  : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n","import { ResultAsync } from './result-async.js'\nimport type { Result } from './result.js'\nimport { err, ok } from './result.js'\n\n// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = {\n  [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never\n}\n\n// Given a list of ResultAsyncs, this extracts all the different `T` types from that list\nexport type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {\n  [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never\n}\n\n// Given a list of Results, this extracts all the different `E` types from that list\nexport type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = {\n  [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never\n}\n\n// Given a list of ResultAsyncs, this extracts all the different `E` types from that list\nexport type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = {\n  [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never\n}\n\nexport type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never\nexport type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never\n\nexport type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never\nexport type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never\n\n/**\n * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n  resultList: readonly Result<T, E>[],\n): Result<readonly T[], E> => {\n  let acc = ok([]) as Result<T[], E>\n\n  for (const result of resultList) {\n    if (result.isErr()) {\n      acc = err(result.error)\n      break\n    } else {\n      acc.map((list) => list.push(result.value))\n    }\n  }\n  return acc\n}\n\n/* This is the typesafe version of Promise.all\n *\n * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values\n * or fails if one (or more) of the inner results are Err values\n */\nexport const combineResultAsyncList = <T, E>(\n  asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E> =>\n  ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultList,\n  ) as ResultAsync<T[], E>\n\n/**\n * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n  resultList: readonly Result<T, E>[],\n): Result<readonly T[], E[]> => {\n  let acc = ok([]) as Result<T[], E[]>\n\n  for (const result of resultList) {\n    if (result.isErr() && acc.isErr()) {\n      acc.error.push(result.error)\n    } else if (result.isErr() && acc.isOk()) {\n      acc = err([result.error])\n    } else if (result.isOk() && acc.isOk()) {\n      acc.value.push(result.value)\n    }\n    // do nothing when result.isOk() && acc.isErr()\n  }\n  return acc\n}\n\nexport const combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: readonly ResultAsync<T, E>[],\n): ResultAsync<readonly T[], E[]> =>\n  ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultListWithAllErrors,\n  ) as ResultAsync<T[], E[]>\n"],"mappings":"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","names":["ok"]}

package/dist/error.d.cts

@@ -1 +1 @@
-export { K as ErrorConfig, L as createResultarError } from './index-Ct3o3to5.cjs';
+export { N as ErrorConfig, O as createResultarError } from './index-rRvCJDjp.cjs';

package/dist/error.d.ts

@@ -1 +1 @@
-export { K as ErrorConfig, L as createResultarError } from './index-Ct3o3to5.js';
+export { N as ErrorConfig, O as createResultarError } from './index-rRvCJDjp.js';

package/dist/{index-Ct3o3to5.d.cts → index-rRvCJDjp.d.cts}

@@ -32,8 +32,42 @@ declare class DisposableResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     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>`
+ * Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.
+ * This class provides a way to handle asynchronous operations that may succeed with a value of type T
+ * or fail with an error of type E.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ *
+ * @implements {PromiseLike<Result<T, E>>}
+ *
+ * @example
+ * ```typescript
+ * // Create a successful async result
+ * const okAsync = ResultAsync.okAsync(42);
+ *
+ * // Create a failed async result
+ * const errAsync = ResultAsync.errAsync(new Error("Something went wrong"));
+ *
+ * // Transform a Promise into a ResultAsync
+ * const resultFromPromise = ResultAsync.fromPromise(
+ *   fetch("https://api.example.com/data"),
+ *   (error) => new Error(`API call failed: ${error}`)
+ * );
+ * ```
+ *
+ * @remarks
+ * ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.
+ * It provides various utility methods for transforming and combining results, similar to the Result type,
+ * but operating in an asynchronous context.
+ *
+ * The class includes methods for:
+ * - Creating ResultAsync instances (okAsync, errAsync, fromPromise)
+ * - Transforming values (map, mapErr)
+ * - Chaining operations (andThen, orElse)
+ * - Error handling (tapError)
+ * - Conditional branching (if)
+ * - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
  */
 declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     /**
@@ -56,6 +90,28 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
      * @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>;
+    /**
+     * Creates a ResultAsync from a Promise, catching any errors that occur during its execution.
+     *
+     * @param fn - The Promise to be wrapped in a ResultAsync.
+     * @param errorFn - Optional function to transform the caught error into a specific error type.
+     *                  If not provided, the original error will be used.
+     * @returns A ResultAsync that will resolve to Ok with the promise's value if successful,
+     *          or Err with either the transformed error (if errorFn is provided) or the original error.
+     *
+     * @example
+     * ```typescript
+     * // Without error transformer
+     * const result = ResultAsync.tryCatch(Promise.resolve(42));
+     *
+     * // With error transformer
+     * const result = ResultAsync.tryCatch(
+     *   fetch('https://api.example.com'),
+     *   (error) => new CustomError('API request failed')
+     * );
+     * ```
+     */
+    static tryCatch<T, E>(fn: Promise<T>, errorFn?: (e: unknown) => 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.
@@ -105,7 +161,7 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
     match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
     unwrapOr<A>(t: A): Promise<T | A>;
-    unwrapOrThrow(): Promise<T | E>;
+    unwrapOrThrow(): Promise<T>;
     /**
      * Performs a side effect for the `Ok` variant of `ResultAsync`.
      * This function can be used for control flow based on result values.
@@ -157,6 +213,7 @@ declare const fromPromise: typeof ResultAsync.fromPromise;
 declare const fromSafePromise: typeof ResultAsync.fromSafePromise;
 declare const unitAsync: typeof ResultAsync.unitAsync;
 declare const fromThrowableAsync: typeof ResultAsync.fromThrowable;
+declare const tryCatchAsync: typeof ResultAsync.tryCatch;
 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;
@@ -217,6 +274,16 @@ interface Resultable<T, E> {
  */
 declare class Result<T, E> implements Resultable<T, E> {
     private readonly state;
+    /**
+     * Creates a `Result` by running a function that might throw.
+     * If the function throws, the error will be caught and returned as an `Err`.
+     * If the function succeeds, the value will be wrapped in an `Ok`.
+     *
+     * @param fn - The function to execute, which might throw an error
+     * @param errorFn - Optional function to transform the thrown error before wrapping in `Err`
+     * @returns A `Result` containing either the function's return value or the caught error
+     */
+    static tryCatch<T, E>(fn: () => Exclude<T, Promise<unknown>>, errorFn?: (e: unknown) => E): Result<T, E>;
     /**
      * Wraps a function with a try catch, creating a new function with the same
      * arguments but returning `Ok` if successful, `Err` if the function throws
@@ -239,9 +306,15 @@ 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>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResults<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>,
+        ...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;
@@ -366,7 +439,7 @@ declare class Result<T, E> implements Resultable<T, E> {
      * @param f The function that will be called to clean up the resources
      */
     finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>;
-    unwrapOrThrow(): T | E;
+    unwrapOrThrow(): T;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -436,6 +509,7 @@ declare const ok: typeof Result.ok;
 declare const err: typeof Result.err;
 declare const fromThrowable: typeof Result.fromThrowable;
 declare const unit: typeof Result.unit;
+declare const tryCatch: typeof Result.tryCatch;
 type Prev = [
     never,
     0,
@@ -530,4 +604,4 @@ interface ResultarError<T, E> extends Error {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-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 };
+export { tryCatch as A, type Combine as B, type CombineResultAsyncs as C, DisposableResultAsync as D, type ExtractOkTypes as E, type Dedup as F, type EmptyArrayToNever as G, type MembersToUnion as H, type InferOkTypes as I, type IsLiteralArray as J, type CombineResults as K, type CombineResultsWithAllErrorsArray as L, type MemberListOf as M, type ErrorConfig as N, createResultarError as O, 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, tryCatchAsync as t, unitAsync as u, safeTry as v, ok as w, err as x, fromThrowable as y, unit as z };