resultar 0.5.0 → 0.6.0

package/README.md

@@ -1,4 +1,4 @@
-# Resultar 🙅
+# Resultar
 
 ## Description
 

package/dist/{chunk-DBDW2LXV.js → chunk-L47MDOUR.js}

@@ -142,6 +142,22 @@ var Result = class _Result {
     }
     return fnErr(this.error);
   }
+  /**
+   * Performs a side effect for the `Ok` variant of `Result`.
+   *
+   * @param f The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  tap(f) {
+    if (this.state.ok) {
+      try {
+        f(this.value);
+      } catch {
+      }
+      return ok(this.value);
+    }
+    return err(this.error);
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -244,6 +260,20 @@ var ResultAsync = class _ResultAsync {
   async match(ok2, _err) {
     return this.innerPromise.then((res) => res.match(ok2, _err));
   }
+  tap(f) {
+    return new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isErr()) {
+          return errAsync(res.error);
+        }
+        try {
+          await f(res.value);
+        } catch {
+        }
+        return okAsync(res.value);
+      })
+    );
+  }
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
@@ -263,6 +293,19 @@ function okAsync(value) {
 function errAsync(error) {
   return new ResultAsync(Promise.resolve(Result.err(error)));
 }
+function fromThrowableAsync(fn, errorFn) {
+  return (...args) => new ResultAsync(
+    (async () => {
+      try {
+        const v = await fn(...args);
+        return Result.ok(v);
+      } catch (error) {
+        const e = errorFn ? errorFn(error) : error;
+        return Result.err(e);
+      }
+    })()
+  );
+}
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -281,6 +324,7 @@ export {
   fromPromise,
   okAsync,
   errAsync,
+  fromThrowableAsync,
   safeTryAsync,
   Result,
   ok,
@@ -288,4 +332,4 @@ export {
   fromThrowable,
   safeTry
 };
-//# sourceMappingURL=chunk-DBDW2LXV.js.map
+//# sourceMappingURL=chunk-L47MDOUR.js.map

package/dist/{chunk-DBDW2LXV.js.map → chunk-L47MDOUR.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts","../src/result-async.ts"],"sourcesContent":["import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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   * **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\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","import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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  /**\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 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"],"mappings":"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","names":["ok"]}
+{"version":3,"sources":["../src/result.ts","../src/result-async.ts"],"sourcesContent":["import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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 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\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","import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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"],"mappings":"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","names":["ok"]}

package/dist/error.d.cts

@@ -1 +1 @@
-export { E as ErrorConfig, i as createResultarError } from './index-CyqyqPfg.cjs';
+export { E as ErrorConfig, j as createResultarError } from './index-BsQaA54t.cjs';

package/dist/error.d.ts

@@ -1 +1 @@
-export { E as ErrorConfig, i as createResultarError } from './index-CyqyqPfg.js';
+export { E as ErrorConfig, j as createResultarError } from './index-BsQaA54t.js';

package/dist/{index-CyqyqPfg.d.cts → index-BsQaA54t.d.cts}

@@ -11,6 +11,7 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
     andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
     match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X>;
+    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
     /**
      * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
      */
@@ -20,6 +21,7 @@ declare function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultA
 declare function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
 declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
 declare function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+declare function fromThrowableAsync<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
 declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
 
 declare class Result<T, E> {
@@ -128,6 +130,13 @@ declare class Result<T, E> {
      * @param err
      */
     match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
+    /**
+     * Performs a side effect for the `Ok` variant of `Result`.
+     *
+     * @param f The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    tap(f: (t: T) => void): Result<T, E>;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -193,4 +202,4 @@ interface ResultarError<T, E> {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, Result as b, ok as c, err as d, errAsync as e, fromSafePromise as f, fromThrowable as g, safeTry as h, createResultarError as i, okAsync as o, safeTryAsync as s };
+export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, fromThrowableAsync as b, Result as c, ok as d, errAsync as e, fromSafePromise as f, err as g, fromThrowable as h, safeTry as i, createResultarError as j, okAsync as o, safeTryAsync as s };

package/dist/{index-CyqyqPfg.d.ts → index-BsQaA54t.d.ts}

@@ -11,6 +11,7 @@ declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<R, R | E>;
     andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
     match<X>(ok: (t: T) => X, _err: (e: E) => X): Promise<X>;
+    tap(f: (t: T) => void | Promise<void>): ResultAsync<T, E>;
     /**
      * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
      */
@@ -20,6 +21,7 @@ declare function fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultA
 declare function fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
 declare function okAsync<T, E = never>(value: T): ResultAsync<T, E>;
 declare function errAsync<T = never, E = unknown>(error: E): ResultAsync<T, E>;
+declare function fromThrowableAsync<A extends readonly any[], T, E>(fn: (...args: A) => Promise<T>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<T, E>;
 declare function safeTryAsync<T, E>(body: () => AsyncGenerator<Result<never, E>, Result<T, E>>): ResultAsync<T, E>;
 
 declare class Result<T, E> {
@@ -128,6 +130,13 @@ declare class Result<T, E> {
      * @param err
      */
     match<X>(fnOk: (t: T) => X, fnErr: (e: E) => X): X;
+    /**
+     * Performs a side effect for the `Ok` variant of `Result`.
+     *
+     * @param f The function to apply an `OK` value
+     * @returns the result of applying `f` or an `Err` untouched
+     */
+    tap(f: (t: T) => void): Result<T, E>;
     /**
      * **This method is unsafe, and should only be used in a test environments**
      *
@@ -193,4 +202,4 @@ interface ResultarError<T, E> {
 }
 declare const createResultarError: <T, E>(message: string, result: Result<T, E>, config?: ErrorConfig) => ResultarError<T, E>;
 
-export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, Result as b, ok as c, err as d, errAsync as e, fromSafePromise as f, fromThrowable as g, safeTry as h, createResultarError as i, okAsync as o, safeTryAsync as s };
+export { type ErrorConfig as E, ResultAsync as R, fromPromise as a, fromThrowableAsync as b, Result as c, ok as d, errAsync as e, fromSafePromise as f, err as g, fromThrowable as h, safeTry as i, createResultarError as j, okAsync as o, safeTryAsync as s };

package/dist/index.cjs

@@ -27,6 +27,7 @@ __export(src_exports, {
   fromPromise: () => fromPromise,
   fromSafePromise: () => fromSafePromise,
   fromThrowable: () => fromThrowable,
+  fromThrowableAsync: () => fromThrowableAsync,
   ok: () => ok,
   okAsync: () => okAsync,
   safeTry: () => safeTry,
@@ -98,6 +99,20 @@ var ResultAsync = class _ResultAsync {
   async match(ok2, _err) {
     return this.innerPromise.then((res) => res.match(ok2, _err));
   }
+  tap(f) {
+    return new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isErr()) {
+          return errAsync(res.error);
+        }
+        try {
+          await f(res.value);
+        } catch {
+        }
+        return okAsync(res.value);
+      })
+    );
+  }
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
@@ -117,6 +132,19 @@ function okAsync(value) {
 function errAsync(error) {
   return new ResultAsync(Promise.resolve(Result.err(error)));
 }
+function fromThrowableAsync(fn, errorFn) {
+  return (...args) => new ResultAsync(
+    (async () => {
+      try {
+        const v = await fn(...args);
+        return Result.ok(v);
+      } catch (error) {
+        const e = errorFn ? errorFn(error) : error;
+        return Result.err(e);
+      }
+    })()
+  );
+}
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -269,6 +297,22 @@ var Result = class _Result {
     }
     return fnErr(this.error);
   }
+  /**
+   * Performs a side effect for the `Ok` variant of `Result`.
+   *
+   * @param f The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  tap(f) {
+    if (this.state.ok) {
+      try {
+        f(this.value);
+      } catch {
+      }
+      return ok(this.value);
+    }
+    return err(this.error);
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -329,6 +373,7 @@ function safeTry(body) {
   fromPromise,
   fromSafePromise,
   fromThrowable,
+  fromThrowableAsync,
   ok,
   okAsync,
   safeTry,

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/error.ts","../src/result-async.ts","../src/result.ts"],"sourcesContent":["export * from './result.js'\nexport * from './result-async.js'\n","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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  /**\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 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","import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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   * **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\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"],"mappings":"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","names":["ok"]}
+{"version":3,"sources":["../src/index.ts","../src/error.ts","../src/result-async.ts","../src/result.ts"],"sourcesContent":["export * from './result.js'\nexport * from './result-async.js'\n","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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","import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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 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\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"],"mappings":"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","names":["ok"]}

package/dist/index.d.cts

@@ -1 +1 @@
-export { b as Result, R as ResultAsync, d as err, e as errAsync, a as fromPromise, f as fromSafePromise, g as fromThrowable, c as ok, o as okAsync, h as safeTry, s as safeTryAsync } from './index-CyqyqPfg.cjs';
+export { c as Result, R as ResultAsync, g as err, e as errAsync, a as fromPromise, f as fromSafePromise, h as fromThrowable, b as fromThrowableAsync, d as ok, o as okAsync, i as safeTry, s as safeTryAsync } from './index-BsQaA54t.cjs';

package/dist/index.d.ts

@@ -1 +1 @@
-export { b as Result, R as ResultAsync, d as err, e as errAsync, a as fromPromise, f as fromSafePromise, g as fromThrowable, c as ok, o as okAsync, h as safeTry, s as safeTryAsync } from './index-CyqyqPfg.js';
+export { c as Result, R as ResultAsync, g as err, e as errAsync, a as fromPromise, f as fromSafePromise, h as fromThrowable, b as fromThrowableAsync, d as ok, o as okAsync, i as safeTry, s as safeTryAsync } from './index-BsQaA54t.js';

package/dist/index.js

@@ -6,11 +6,12 @@ import {
   fromPromise,
   fromSafePromise,
   fromThrowable,
+  fromThrowableAsync,
   ok,
   okAsync,
   safeTry,
   safeTryAsync
-} from "./chunk-DBDW2LXV.js";
+} from "./chunk-L47MDOUR.js";
 import "./chunk-FBVQYZXO.js";
 export {
   Result,
@@ -20,6 +21,7 @@ export {
   fromPromise,
   fromSafePromise,
   fromThrowable,
+  fromThrowableAsync,
   ok,
   okAsync,
   safeTry,

package/dist/result-async.cjs

@@ -24,6 +24,7 @@ __export(result_async_exports, {
   errAsync: () => errAsync,
   fromPromise: () => fromPromise,
   fromSafePromise: () => fromSafePromise,
+  fromThrowableAsync: () => fromThrowableAsync,
   okAsync: () => okAsync,
   safeTryAsync: () => safeTryAsync
 });
@@ -183,6 +184,22 @@ var Result = class _Result {
     }
     return fnErr(this.error);
   }
+  /**
+   * Performs a side effect for the `Ok` variant of `Result`.
+   *
+   * @param f The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  tap(f) {
+    if (this.state.ok) {
+      try {
+        f(this.value);
+      } catch {
+      }
+      return ok(this.value);
+    }
+    return err(this.error);
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *
@@ -277,6 +294,20 @@ var ResultAsync = class _ResultAsync {
   async match(ok2, _err) {
     return this.innerPromise.then((res) => res.match(ok2, _err));
   }
+  tap(f) {
+    return new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isErr()) {
+          return errAsync(res.error);
+        }
+        try {
+          await f(res.value);
+        } catch {
+        }
+        return okAsync(res.value);
+      })
+    );
+  }
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
@@ -296,6 +327,19 @@ function okAsync(value) {
 function errAsync(error) {
   return new ResultAsync(Promise.resolve(Result.err(error)));
 }
+function fromThrowableAsync(fn, errorFn) {
+  return (...args) => new ResultAsync(
+    (async () => {
+      try {
+        const v = await fn(...args);
+        return Result.ok(v);
+      } catch (error) {
+        const e = errorFn ? errorFn(error) : error;
+        return Result.err(e);
+      }
+    })()
+  );
+}
 function safeTryAsync(body) {
   return new ResultAsync(
     (async () => {
@@ -313,6 +357,7 @@ function safeTryAsync(body) {
   errAsync,
   fromPromise,
   fromSafePromise,
+  fromThrowableAsync,
   okAsync,
   safeTryAsync
 });

package/dist/result-async.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result-async.ts","../src/error.ts","../src/result.ts"],"sourcesContent":["import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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  /**\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 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","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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   * **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\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"],"mappings":"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","names":["ok"]}
+{"version":3,"sources":["../src/result-async.ts","../src/error.ts","../src/result.ts"],"sourcesContent":["import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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 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\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"],"mappings":"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","names":["ok"]}

package/dist/result-async.d.cts

@@ -1 +1 @@
-export { R as ResultAsync, e as errAsync, a as fromPromise, f as fromSafePromise, o as okAsync, s as safeTryAsync } from './index-CyqyqPfg.cjs';
+export { R as ResultAsync, e as errAsync, a as fromPromise, f as fromSafePromise, b as fromThrowableAsync, o as okAsync, s as safeTryAsync } from './index-BsQaA54t.cjs';

package/dist/result-async.d.ts

@@ -1 +1 @@
-export { R as ResultAsync, e as errAsync, a as fromPromise, f as fromSafePromise, o as okAsync, s as safeTryAsync } from './index-CyqyqPfg.js';
+export { R as ResultAsync, e as errAsync, a as fromPromise, f as fromSafePromise, b as fromThrowableAsync, o as okAsync, s as safeTryAsync } from './index-BsQaA54t.js';

package/dist/result-async.js

@@ -3,15 +3,17 @@ import {
   errAsync,
   fromPromise,
   fromSafePromise,
+  fromThrowableAsync,
   okAsync,
   safeTryAsync
-} from "./chunk-DBDW2LXV.js";
+} from "./chunk-L47MDOUR.js";
 import "./chunk-FBVQYZXO.js";
 export {
   ResultAsync,
   errAsync,
   fromPromise,
   fromSafePromise,
+  fromThrowableAsync,
   okAsync,
   safeTryAsync
 };

package/dist/result.cjs

@@ -92,6 +92,20 @@ var ResultAsync = class _ResultAsync {
   async match(ok2, _err) {
     return this.innerPromise.then((res) => res.match(ok2, _err));
   }
+  tap(f) {
+    return new _ResultAsync(
+      this.innerPromise.then(async (res) => {
+        if (res.isErr()) {
+          return errAsync(res.error);
+        }
+        try {
+          await f(res.value);
+        } catch {
+        }
+        return okAsync(res.value);
+      })
+    );
+  }
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
@@ -246,6 +260,22 @@ var Result = class _Result {
     }
     return fnErr(this.error);
   }
+  /**
+   * Performs a side effect for the `Ok` variant of `Result`.
+   *
+   * @param f The function to apply an `OK` value
+   * @returns the result of applying `f` or an `Err` untouched
+   */
+  tap(f) {
+    if (this.state.ok) {
+      try {
+        f(this.value);
+      } catch {
+      }
+      return ok(this.value);
+    }
+    return err(this.error);
+  }
   /**
    * **This method is unsafe, and should only be used in a test environments**
    *

package/dist/result.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/result.ts","../src/error.ts","../src/result-async.ts"],"sourcesContent":["import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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   * **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\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","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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  /**\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 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"],"mappings":"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","names":["ok"]}
+{"version":3,"sources":["../src/result.ts","../src/error.ts","../src/result-async.ts"],"sourcesContent":["import { ErrorConfig, createResultarError } from './error.js'\nimport { ResultAsync, errAsync } from './result-async.js'\n\ninterface Ok<T> {\n  ok: true\n  value: T\n}\n\ninterface Err<E> {\n  ok: false\n  error: E\n}\n\nexport class Result<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>({ ok: true, value })\n  }\n\n  static err<T=never, E=unknown>(error: E): Result<T, E> {\n    return new Result<T, E>({ ok: false, error })\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) => Exclude<X, Promise<any>>): Result<X, E | Y>\n  map<X>(f: (t: T) => Exclude<X, Promise<any>>): 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 as Exclude<E, Promise<any>>)\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: Exclude<E, Promise<any>>) => Exclude<X, Promise<any>>): Result<T, X> {\n    if (this.state.ok) {\n      return ok(this.value as Exclude<T, Promise<any>>)\n    }\n\n    return err(fn(this.error as Exclude<E, Promise<any>>))\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) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y>\n  andThen<X, Y>(f: (t: T) => Exclude<Result<X, Y>, Promise<any>>): Result<X, E | Y> {\n    if (this.state.ok) {\n      return f(this.value)\n    }\n\n    return err(this.error as Exclude<E, Promise<any>>)\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 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\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","import { Result } from './result.js'\n\nexport interface ErrorConfig {\n  withStackTrace: boolean\n}\n\nconst defaultErrorConfig: ErrorConfig = {\n  withStackTrace: false,\n}\n\ninterface ResultarError<T, E> {\n  data:\n  | {\n    type: string\n    value: T | undefined\n  }\n  | {\n    type: string\n    value: E | undefined\n  }\n  message: string\n  stack: string | undefined\n}\n\nexport const createResultarError = <T, E>(\n  message: string,\n  result: Result<T, E>,\n  config: ErrorConfig = defaultErrorConfig,\n): ResultarError<T, E> => {\n  const data = result.isOk()\n    ? { type: 'Ok', value: result.value }\n    : { type: 'Err', value: result.error }\n\n  const maybeStack = config.withStackTrace ? new Error().stack : undefined // eslint-disable-line unicorn/error-message\n\n  return {\n    data,\n    message,\n    stack: maybeStack,\n  }\n}\n","import {\n  Result,\n} from './result.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  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<R, R | E>\n  andThen<R extends ResultAsync<unknown, unknown>>(\n    f: (t: T) => R,\n  ): ResultAsync<R, R | E>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>\n  andThen<X, Y>(f: (t: T) => ResultAsync<X, E>): ResultAsync<X, E | Y> {\n    return new ResultAsync<X, E | Y>(\n      this.innerPromise.then(async res => {\n        if (res.isErr()) {\n          return errAsync(res.error)\n        }\n\n        const newValue = f(res.value)\n        return newValue instanceof ResultAsync ? newValue.innerPromise : newValue\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"],"mappings":"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","names":["ok"]}

package/dist/result.d.cts

@@ -1 +1 @@
-export { b as Result, d as err, g as fromThrowable, c as ok, h as safeTry } from './index-CyqyqPfg.cjs';
+export { c as Result, g as err, h as fromThrowable, d as ok, i as safeTry } from './index-BsQaA54t.cjs';

package/dist/result.d.ts

@@ -1 +1 @@
-export { b as Result, d as err, g as fromThrowable, c as ok, h as safeTry } from './index-CyqyqPfg.js';
+export { c as Result, g as err, h as fromThrowable, d as ok, i as safeTry } from './index-BsQaA54t.js';

package/dist/result.js

@@ -4,7 +4,7 @@ import {
   fromThrowable,
   ok,
   safeTry
-} from "./chunk-DBDW2LXV.js";
+} from "./chunk-L47MDOUR.js";
 import "./chunk-FBVQYZXO.js";
 export {
   Result,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resultar",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Result pattern for typescript",
   "type": "module",
   "packageManager": "pnpm@8.15.6",