resultar 0.7.0 → 0.8.0

package/README.md

@@ -973,6 +973,26 @@ resAsync.then((res: Result<void, Error>) => {
 
 [⬆️  Back to top](#toc)
 
+---
+#### `Result.tap` (method)
+Executes a side effect function with the `Ok` value and returns the original `Result`.
+This method is useful for performing actions that do not modify the `Result` itself, such as logging or updating external state.
+**Signature:**
+```typescript
+class ResultAsync<T, E> {
+  tap(f: (t: T) => void): Result<T, E> {..}
+}
+```
+
+**Example:**
+```typescript
+const fooValue = ok('foo')
+
+const mapped = okVal.tap((value) => {
+  console.log(value) // print foo
+})
+// mapped.value === 'foo'
+
 ---
 
 #### `ResultAsync.orElse` (method)

package/dist/{chunk-JJ6JC2TK.js → chunk-ZFWL27DT.js}

@@ -200,6 +200,14 @@ var Result2 = class _Result {
     }
     return err(this.error);
   }
+  finally(f) {
+    const resultDisposable = new DisposableResult(this, f);
+    try {
+      return resultDisposable;
+    } finally {
+      resultDisposable[Symbol.dispose]();
+    }
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -241,6 +249,36 @@ var Result2 = class _Result {
     }();
   }
 };
+var DisposableResult = class {
+  constructor(result, finalizer) {
+    this.result = result;
+    this.finalizer = finalizer;
+  }
+  get value() {
+    return this.result.value;
+  }
+  get error() {
+    return this.result.error;
+  }
+  _unsafeUnwrap(config) {
+    return this.result._unsafeUnwrap(config);
+  }
+  _unsafeUnwrapErr(config) {
+    return this.result._unsafeUnwrapErr(config);
+  }
+  isOk() {
+    return this.result.isOk();
+  }
+  isErr() {
+    return this.result.isErr();
+  }
+  unwrapOr(defaultValue) {
+    return this.result.unwrapOr(defaultValue);
+  }
+  [Symbol.dispose]() {
+    this.finalizer(this.result.value, this.result.error);
+  }
+};
 var ok = (value) => Result2.ok(value);
 var err = (error) => Result2.err(error);
 var fromThrowable = (fn, errorFn) => Result2.fromThrowable(fn, errorFn);
@@ -382,9 +420,10 @@ export {
   combineResultAsyncListWithAllErrors,
   combineResultListWithAllErrors,
   Result2 as Result,
+  DisposableResult,
   ok,
   err,
   fromThrowable,
   safeTry
 };
-//# sourceMappingURL=chunk-JJ6JC2TK.js.map
+//# sourceMappingURL=chunk-ZFWL27DT.js.map

package/dist/chunk-ZFWL27DT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts","../src/result.ts","../src/result-async.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/ban-types */\nimport { ResultAsync } from './result-async.js'\nimport { Result, ok, err } from './result.js'\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>\n  ? 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\n      ? V\n      : never\n    : never\n) extends (_: unknown) => infer W\n  ? [...MemberListOf<Exclude<T, W>>, W]\n  : []\n\n// Given a list of Results, this extracts all the different `T` types from that list\nexport type ExtractOkTypes<T extends ReadonlyArray<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 ReadonlyArray<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 ReadonlyArray<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 ReadonlyArray<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// Checks if the given type is a literal array.\nexport type IsLiteralArray<T> = T extends { length: infer L }\n  ? L extends number\n    ? number extends L\n      ? 0\n      : 1\n    : 0\n  : 0\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 []\n  ? never\n  : NeverArrayToNever extends 1\n    ? T extends [never, ...infer Rest]\n      ? [EmptyArrayToNever<Rest>] extends [never]\n        ? never\n        : T\n      : T\n    : T\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.\n    type 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      ...Array<0>,\n    ]\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[]\n        ? PR extends unknown[]\n          ? 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// 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<T, Collected extends unknown[] = [], Depth extends number = 50> = [\n  Depth,\n] extends [never]\n  ? []\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// 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// 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]\n  ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>]\n  : Transpose<CollectResults<T>, [], Depth> extends []\n    ? [[], []]\n    : never\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> = Combine<T, Depth> extends [\n  infer Oks,\n  infer Errs,\n]\n  ? Result<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n  : never\n\nconst appendValueToEndOfList = <T>(value: T) => (list: T[]): T[] => [...list, value]\n\nexport type CombineResults<\n  T extends ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? 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 ReadonlyArray<Result<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? TraverseWithAllErrors<T>\n  : Result<ExtractOkTypes<T>, Array<ExtractErrTypes<T>[number]>>\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: ReadonlyArray<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 * Short circuits on the FIRST Err value that we find\n */\nexport const combineResultList = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E> =>\n  resultList.reduce<Result<T[], E>>( // eslint-disable-line unicorn/no-array-reduce\n    (acc, result) =>\n      acc.isOk()\n        ? (result.isErr()\n          ? err(result.error)\n          : acc.map(appendValueToEndOfList(result.value)))\n        : acc,\n    ok([]),\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 combineResultAsyncListWithAllErrors = <T, E>(\n  asyncResultList: ReadonlyArray<ResultAsync<T, E>>,\n): ResultAsync<readonly T[], E[]> => {\n  const x = ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(\n    combineResultListWithAllErrors,\n  )\n  return x as ResultAsync<T[], E[]>\n}\n\n/**\n * Give a list of all the errors we find\n */\nexport const combineResultListWithAllErrors = <T, E>(\n  resultList: ReadonlyArray<Result<T, E>>,\n): Result<readonly T[], E[]> =>\n  resultList.reduce<Result<T[], E[]>>( // eslint-disable-line unicorn/no-array-reduce\n    (acc, result) =>\n      result.isErr()\n        ? (acc.isErr()\n          ? err([...acc.error, result.error])\n          : err([result.error]))\n        : (acc.isErr()\n          ? acc\n          : ok([...acc.value, result.value])),\n    ok([]),\n  )\n\n","import {\n  CombineResults, CombineResultsWithAllErrorsArray, combineResultList, combineResultListWithAllErrors,\n} from './utils.js'\nimport { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\nclass Ok<T> {\n  readonly ok = true // eslint-disable-line @typescript-eslint/class-literal-property-style\n  constructor(public readonly value: T) {}\n}\n\nclass Err<E> {\n  readonly ok = false // eslint-disable-line @typescript-eslint/class-literal-property-style\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\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\nexport class Result<T, E> implements Resultable<T, E> {\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  static fromThrowable<Fn extends (...args: readonly any[]) => unknown, E>(\n    fn: Fn,\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  static ok<T, E=never>(value: T): Result<T, E> {\n    return new Result<T, E>(new Ok(value))\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 [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T>\n  static combine<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResults<T>\n  static combine<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResults<T> {\n    return combineResultList(resultList) as CombineResults<T>\n  }\n\n  static combineWithAllErrors<\n    T extends readonly [Result<unknown, unknown>, ...Array<Result<unknown, unknown>>],\n  >(resultList: T): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T>\n  static combineWithAllErrors<T extends ReadonlyArray<Result<unknown, unknown>>>(\n    resultList: T,\n  ): CombineResultsWithAllErrorsArray<T> {\n    return combineResultListWithAllErrors(resultList) 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, Y>(f: (t: T) => X): Result<X, E | Y>\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  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  /**\n   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.\n   *\n   * This is useful for error recovery.\n   *\n   *\n   * @param f  A function to apply to an `Err` value, leaving `Ok` values\n   * untouched.\n   */\n  orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, Y>\n  orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, E | Y> {\n    if (this.state.ok) {\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   *\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<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X {\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` variant of `Result`.\n   *\n   * @param f The function to apply an `OK` value\n   * @returns the result of applying `f` or an `Err` untouched\n   */\n  tap(f: (t: T) => void): Result<T, E> {\n    if (this.state.ok) {\n      try {\n        f(this.value)\n      } catch {\n        // Dont do anything. Its just a tap\n      }\n\n      return ok(this.value)\n    }\n\n    return err(this.error)\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>(f: (value: X, error: Y) => void): 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]() // eslint-disable-line no-use-extend-native/no-use-extend-native\n    }\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) // eslint-disable-line @typescript-eslint/no-throw-literal\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('Called `_unsafeUnwrapErr` on an Ok', this, config) // eslint-disable-line @typescript-eslint/no-throw-literal\n    }\n\n    return this.error\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(readonly result: Resultable<T, E>,\n    private readonly finalizer: (value: T, error: E) => void) {}\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 | undefined): T {\n    return this.result._unsafeUnwrap(config)\n  }\n\n  _unsafeUnwrapErr(config?: ErrorConfig | undefined): 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\nexport const ok = <T, E = never>(value: T): Result<T, E> => Result.ok(value)\nexport const err = <T = never, E = unknown>(error: E): Result<T, E> => Result.err(error)\nexport const fromThrowable = <Fn extends (...args: readonly any[]) => unknown, E>(\n  fn: Fn,\n  errorFn?: (e: any) => E,\n): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E> => Result.fromThrowable(fn, errorFn)\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>(body: () => Generator<Result<never, E>, Result<T, E>>): Result<T, E>\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 */\n// NOTE:\n// Since body is potentially throwable because `await` can be used in it,\n// Promise<Result<T, E>>, not ResultAsync<T, E>, is used as the return type.\nexport function safeTry<T, E>(\n  body: () => AsyncGenerator<Result<never, E>, Result<T, E>>,\n): Promise<Result<T, E>>\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> | Promise<Result<T, E>> {\n  const n = body().next()\n  if (n instanceof Promise) {\n    return n.then(r => r.value)\n  }\n\n  return n.value\n}\n\n","/* eslint-disable @typescript-eslint/ban-types */\nimport {\n  Result,\n} from './result.js'\nimport {\n  Combine,\n  Dedup,\n  EmptyArrayToNever,\n  ExtractErrAsyncTypes,\n  ExtractOkAsyncTypes,\n  InferAsyncErrTypes, InferAsyncOkTypes, InferErrTypes, InferOkTypes,\n  IsLiteralArray,\n  MemberListOf,\n  MembersToUnion,\n  combineResultAsyncList,\n  combineResultAsyncListWithAllErrors,\n} from './utils.js'\n\nexport class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {\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  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>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultAsyncs<T>\n  static combine<T extends ReadonlyArray<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>, ...Array<ResultAsync<unknown, unknown>>],\n  >(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T>\n  static combineWithAllErrors<T extends ReadonlyArray<ResultAsync<unknown, unknown>>>(\n    asyncResultList: T,\n  ): CombineResultsWithAllErrorsArrayAsync<T> {\n    return combineResultAsyncListWithAllErrors(\n      asyncResultList,\n    ) as CombineResultsWithAllErrorsArrayAsync<T>\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  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        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  async match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X> {\n    return this.innerPromise.then(res => res.match(ok, _err))\n  }\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 {\n          // Dont do anything. Its just a tap\n        }\n\n        return okAsync(res.value)\n      }),\n    )\n  }\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\nexport function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>\nexport function fromSafePromise<T, E = never>(promise:\n| PromiseLike<T>\n| Promise<T>): ResultAsync<T, E> {\n  return ResultAsync.fromSafePromise(promise)\n}\n\nexport function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>\nexport function fromPromise<T, E>(promise:\n| PromiseLike<T>\n| Promise<T>, errorFn: (e: unknown) => E): ResultAsync<T, E> {\n  return ResultAsync.fromPromise(promise, errorFn)\n}\n\nexport function okAsync<T, E = never>(value: T): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(Promise.resolve(Result.ok(value)))\n}\n\nexport function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E> {\n  return new ResultAsync<T, E>(Promise.resolve(Result.err(error)))\n}\n\nexport function fromThrowableAsync<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) => 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\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\n// Combines the array of async results into one result.\nexport type CombineResultAsyncs<\n  T extends ReadonlyArray<ResultAsync<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? 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 ReadonlyArray<ResultAsync<unknown, unknown>>,\n> = IsLiteralArray<T> extends 1\n  ? TraverseWithAllErrorsAsync<UnwrapAsync<T>>\n  : ResultAsync<ExtractOkAsyncTypes<T>, Array<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>\n      ? HI extends Result<unknown, unknown>\n        ? [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 Array<infer A>\n    ? A extends PromiseLike<infer HI>\n      ? HI extends Result<infer L, infer R>\n        ? Array<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]\n    ? 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 Array<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[]\n          ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, MembersToUnion<Array<Errs[number]>>>\n          : ResultAsync<EmptyArrayToNever<Array<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[]\n          ? ResultAsync<Oks, MembersToUnion<Array<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 order. For the checks/conditions made here, see that type\n// for the documentation.\ntype TraverseWithAllErrorsAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1\n  ? Combine<T, Depth> extends [infer Oks, infer Errs]\n    ? ResultAsync<EmptyArrayToNever<Oks>, EmptyArrayToNever<Errs>>\n    : never\n  : Writable<T> extends Array<infer I>\n    ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs]\n      ? Oks extends unknown[]\n        ? Errs extends unknown[]\n          ? ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, EmptyArrayToNever<Array<Errs[number]>>>\n          : ResultAsync<EmptyArrayToNever<Array<Oks[number]>>, Errs>\n        : Errs extends unknown[]\n          ? ResultAsync<Oks, EmptyArrayToNever<Array<Errs[number]>>>\n          : ResultAsync<Oks, Errs>\n      : never\n    : never\n\n// Converts a reaodnly array into a writable array\ntype Writable<T> = T extends readonly unknown[] ? [...T] : T\n"],"mappings":"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","names":["Result","Result","ok"]}

package/dist/error.d.cts

@@ -1 +1 @@
-export { F as ErrorConfig, G as createResultarError } from './index-BY07wubR.cjs';
+export { G as ErrorConfig, H as createResultarError } from './index-ph1sfvDU.cjs';

package/dist/error.d.ts

@@ -1 +1 @@
-export { F as ErrorConfig, G as createResultarError } from './index-BY07wubR.js';
+export { G as ErrorConfig, H as createResultarError } from './index-ph1sfvDU.js';

package/dist/{index-BY07wubR.d.cts → index-ph1sfvDU.d.cts}

@@ -141,7 +141,52 @@ declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: Reado
  */
 declare const combineResultListWithAllErrors: <T, E>(resultList: ReadonlyArray<Result<T, E>>) => Result<readonly T[], E[]>;
 
-declare class Result<T, E> {
+/**
+ * A Result interface that is used to define the methods that are available on a
+ * `Result` object.
+ *
+ * The immutability of the `Result` object is maintained by the interface.
+ */
+interface Resultable<T, E> {
+    get value(): T;
+    get error(): E;
+    /**
+     * Used to check if a `Result` is an `OK`
+     *
+     * @returns `true` if the result is an `OK` variant of Result
+     */
+    isOk(): boolean;
+    /**
+     * Used to check if a `Result` is an `Err`
+     *
+     * @returns `true` if the result is an `Err` variant of Result
+     */
+    isErr(): boolean;
+    /**
+     * Unwrap the `Ok` value, or return the default if there is an `Err`
+     *
+     * @param v the default value to return if there is an `Err`
+     */
+    unwrapOr<A>(defaultValue: A): T | A;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+}
+declare class Result<T, E> implements Resultable<T, E> {
     private readonly state;
     /**
      * Wraps a function with a try catch, creating a new function with the same
@@ -180,7 +225,7 @@ declare class Result<T, E> {
      * @param f The function to apply an `OK` value
      * @returns the result of applying `f` or an `Err` untouched
      */
-    map<X, Y>(f: (t: T) => Exclude<X, Promise<any>>): Result<X, E | Y>;
+    map<X, Y>(f: (t: T) => X): Result<X, E | Y>;
     /**
      * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
      * contained `Err` value, leaving an `Ok` value untouched.
@@ -190,7 +235,7 @@ declare class Result<T, E> {
      *
      * @param f a function to apply to the error `Err` value
      */
-    mapErr<X>(fn: (t: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X>;
+    mapErr<X>(fn: (t: E) => X): Result<T, X>;
     /**
      * Similar to `map` Except you must return a new `Result`.
      *
@@ -201,7 +246,7 @@ declare class Result<T, E> {
      *
      * @param f The function to apply to the current value
      */
-    andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>;
+    andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y>;
     /**
      * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
      *
@@ -258,6 +303,11 @@ declare class Result<T, E> {
      * @returns the result of applying `f` or an `Err` untouched
      */
     tap(f: (t: T) => void): Result<T, E>;
+    /**
+     * This method is used to clean up and release any resources that the `Result`
+     * @param f The function that will be called to clean up the resources
+     */
+    finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -277,6 +327,23 @@ declare class Result<T, E> {
     _unsafeUnwrapErr(config?: ErrorConfig): E;
     safeUnwrap(): Generator<Result<never, E>, T>;
 }
+/**
+ * A `Disposable` is an object that has a `dispose` method that can be used to
+ * clean up resources.
+ */
+declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
+    readonly result: Resultable<T, E>;
+    private readonly finalizer;
+    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;
+    isOk(): boolean;
+    isErr(): boolean;
+    unwrapOr<A>(defaultValue: A): T | A;
+    [Symbol.dispose](): void;
+}
 declare const ok: <T, E = never>(value: T) => Result<T, E>;
 declare const err: <T = never, E = unknown>(error: E) => Result<T, E>;
 declare const fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: ((e: any) => E) | undefined) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
@@ -323,4 +390,4 @@ interface ResultarError<T, E> {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { fromThrowable as A, safeTry as B, type CombineResultAsyncs as C, type Dedup as D, type ExtractOkTypes as E, type ErrorConfig as F, createResultarError as G, type InferOkTypes as I, type MemberListOf as M, ResultAsync as R, type Transpose as T, fromPromise as a, fromThrowableAsync as b, type CombineResultsWithAllErrorsArrayAsync as c, type ExtractOkAsyncTypes as d, errAsync as e, fromSafePromise as f, type ExtractErrTypes as g, type ExtractErrAsyncTypes as h, type InferErrTypes as i, type InferAsyncOkTypes as j, type InferAsyncErrTypes as k, type IsLiteralArray as l, type EmptyArrayToNever as m, type MembersToUnion as n, okAsync as o, type Combine as p, type CombineResults as q, type CombineResultsWithAllErrorsArray as r, safeTryAsync as s, combineResultAsyncList as t, combineResultList as u, combineResultAsyncListWithAllErrors as v, combineResultListWithAllErrors as w, Result as x, ok as y, err as z };
+export { err as A, fromThrowable as B, type CombineResultAsyncs as C, type Dedup as D, type ExtractOkTypes as E, safeTry as F, type ErrorConfig as G, createResultarError as H, type InferOkTypes as I, type MemberListOf as M, ResultAsync as R, type Transpose as T, fromPromise as a, fromThrowableAsync as b, type CombineResultsWithAllErrorsArrayAsync as c, type ExtractOkAsyncTypes as d, errAsync as e, fromSafePromise as f, type ExtractErrTypes as g, type ExtractErrAsyncTypes as h, type InferErrTypes as i, type InferAsyncOkTypes as j, type InferAsyncErrTypes as k, type IsLiteralArray as l, type EmptyArrayToNever as m, type MembersToUnion as n, okAsync as o, type Combine as p, type CombineResults as q, type CombineResultsWithAllErrorsArray as r, safeTryAsync as s, combineResultAsyncList as t, combineResultList as u, combineResultAsyncListWithAllErrors as v, combineResultListWithAllErrors as w, Result as x, DisposableResult as y, ok as z };

package/dist/{index-BY07wubR.d.ts → index-ph1sfvDU.d.ts}

@@ -141,7 +141,52 @@ declare const combineResultAsyncListWithAllErrors: <T, E>(asyncResultList: Reado
  */
 declare const combineResultListWithAllErrors: <T, E>(resultList: ReadonlyArray<Result<T, E>>) => Result<readonly T[], E[]>;
 
-declare class Result<T, E> {
+/**
+ * A Result interface that is used to define the methods that are available on a
+ * `Result` object.
+ *
+ * The immutability of the `Result` object is maintained by the interface.
+ */
+interface Resultable<T, E> {
+    get value(): T;
+    get error(): E;
+    /**
+     * Used to check if a `Result` is an `OK`
+     *
+     * @returns `true` if the result is an `OK` variant of Result
+     */
+    isOk(): boolean;
+    /**
+     * Used to check if a `Result` is an `Err`
+     *
+     * @returns `true` if the result is an `Err` variant of Result
+     */
+    isErr(): boolean;
+    /**
+     * Unwrap the `Ok` value, or return the default if there is an `Err`
+     *
+     * @param v the default value to return if there is an `Err`
+     */
+    unwrapOr<A>(defaultValue: A): T | A;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrap(config?: ErrorConfig): T;
+    /**
+     * **This method is unsafe, and should only be used in a test environments**
+     *
+     * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
+     * otherwise it throws a custom object.
+     *
+     * @param config
+     */
+    _unsafeUnwrapErr(config?: ErrorConfig): E;
+}
+declare class Result<T, E> implements Resultable<T, E> {
     private readonly state;
     /**
      * Wraps a function with a try catch, creating a new function with the same
@@ -180,7 +225,7 @@ declare class Result<T, E> {
      * @param f The function to apply an `OK` value
      * @returns the result of applying `f` or an `Err` untouched
      */
-    map<X, Y>(f: (t: T) => Exclude<X, Promise<any>>): Result<X, E | Y>;
+    map<X, Y>(f: (t: T) => X): Result<X, E | Y>;
     /**
      * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
      * contained `Err` value, leaving an `Ok` value untouched.
@@ -190,7 +235,7 @@ declare class Result<T, E> {
      *
      * @param f a function to apply to the error `Err` value
      */
-    mapErr<X>(fn: (t: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X>;
+    mapErr<X>(fn: (t: E) => X): Result<T, X>;
     /**
      * Similar to `map` Except you must return a new `Result`.
      *
@@ -201,7 +246,7 @@ declare class Result<T, E> {
      *
      * @param f The function to apply to the current value
      */
-    andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>;
+    andThen<X, Y>(f: (t: T) => Result<X, Y>): Result<X, E | Y>;
     /**
      * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
      *
@@ -258,6 +303,11 @@ declare class Result<T, E> {
      * @returns the result of applying `f` or an `Err` untouched
      */
     tap(f: (t: T) => void): Result<T, E>;
+    /**
+     * This method is used to clean up and release any resources that the `Result`
+     * @param f The function that will be called to clean up the resources
+     */
+    finally<X = T, Y = E>(f: (value: X, error: Y) => void): DisposableResult<X, Y>;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -277,6 +327,23 @@ declare class Result<T, E> {
     _unsafeUnwrapErr(config?: ErrorConfig): E;
     safeUnwrap(): Generator<Result<never, E>, T>;
 }
+/**
+ * A `Disposable` is an object that has a `dispose` method that can be used to
+ * clean up resources.
+ */
+declare class DisposableResult<T, E> implements Resultable<T, E>, Disposable {
+    readonly result: Resultable<T, E>;
+    private readonly finalizer;
+    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;
+    isOk(): boolean;
+    isErr(): boolean;
+    unwrapOr<A>(defaultValue: A): T | A;
+    [Symbol.dispose](): void;
+}
 declare const ok: <T, E = never>(value: T) => Result<T, E>;
 declare const err: <T = never, E = unknown>(error: E) => Result<T, E>;
 declare const fromThrowable: <Fn extends (...args: readonly any[]) => unknown, E>(fn: Fn, errorFn?: ((e: any) => E) | undefined) => (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
@@ -323,4 +390,4 @@ interface ResultarError<T, E> {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { fromThrowable as A, safeTry as B, type CombineResultAsyncs as C, type Dedup as D, type ExtractOkTypes as E, type ErrorConfig as F, createResultarError as G, type InferOkTypes as I, type MemberListOf as M, ResultAsync as R, type Transpose as T, fromPromise as a, fromThrowableAsync as b, type CombineResultsWithAllErrorsArrayAsync as c, type ExtractOkAsyncTypes as d, errAsync as e, fromSafePromise as f, type ExtractErrTypes as g, type ExtractErrAsyncTypes as h, type InferErrTypes as i, type InferAsyncOkTypes as j, type InferAsyncErrTypes as k, type IsLiteralArray as l, type EmptyArrayToNever as m, type MembersToUnion as n, okAsync as o, type Combine as p, type CombineResults as q, type CombineResultsWithAllErrorsArray as r, safeTryAsync as s, combineResultAsyncList as t, combineResultList as u, combineResultAsyncListWithAllErrors as v, combineResultListWithAllErrors as w, Result as x, ok as y, err as z };
+export { err as A, fromThrowable as B, type CombineResultAsyncs as C, type Dedup as D, type ExtractOkTypes as E, safeTry as F, type ErrorConfig as G, createResultarError as H, type InferOkTypes as I, type MemberListOf as M, ResultAsync as R, type Transpose as T, fromPromise as a, fromThrowableAsync as b, type CombineResultsWithAllErrorsArrayAsync as c, type ExtractOkAsyncTypes as d, errAsync as e, fromSafePromise as f, type ExtractErrTypes as g, type ExtractErrAsyncTypes as h, type InferErrTypes as i, type InferAsyncOkTypes as j, type InferAsyncErrTypes as k, type IsLiteralArray as l, type EmptyArrayToNever as m, type MembersToUnion as n, okAsync as o, type Combine as p, type CombineResults as q, type CombineResultsWithAllErrorsArray as r, safeTryAsync as s, combineResultAsyncList as t, combineResultList as u, combineResultAsyncListWithAllErrors as v, combineResultListWithAllErrors as w, Result as x, DisposableResult as y, ok as z };

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  DisposableResult: () => DisposableResult,
   Result: () => Result,
   ResultAsync: () => ResultAsync,
   err: () => err,
@@ -364,6 +365,14 @@ var Result = class _Result {
     }
     return err(this.error);
   }
+  finally(f) {
+    const resultDisposable = new DisposableResult(this, f);
+    try {
+      return resultDisposable;
+    } finally {
+      resultDisposable[Symbol.dispose]();
+    }
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -405,6 +414,36 @@ var Result = class _Result {
     }();
   }
 };
+var DisposableResult = class {
+  constructor(result, finalizer) {
+    this.result = result;
+    this.finalizer = finalizer;
+  }
+  get value() {
+    return this.result.value;
+  }
+  get error() {
+    return this.result.error;
+  }
+  _unsafeUnwrap(config) {
+    return this.result._unsafeUnwrap(config);
+  }
+  _unsafeUnwrapErr(config) {
+    return this.result._unsafeUnwrapErr(config);
+  }
+  isOk() {
+    return this.result.isOk();
+  }
+  isErr() {
+    return this.result.isErr();
+  }
+  unwrapOr(defaultValue) {
+    return this.result.unwrapOr(defaultValue);
+  }
+  [Symbol.dispose]() {
+    this.finalizer(this.result.value, this.result.error);
+  }
+};
 var ok = (value) => Result.ok(value);
 var err = (error) => Result.err(error);
 var fromThrowable = (fn, errorFn) => Result.fromThrowable(fn, errorFn);
@@ -417,6 +456,7 @@ function safeTry(body) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DisposableResult,
   Result,
   ResultAsync,
   err,