ts-data-forge 14.6.0 → 14.6.2

package/dist/functional/result/impl/result-from-throwable.mjs

@@ -1,19 +1,46 @@
 import { isError } from '@sindresorhus/is';
-import { unknownToString } from '../../../others/unknown-to-string.mjs';
+import { unknownToString } from '../../../others/index.mjs';
 import { err } from './result-err.mjs';
 import { ok } from './result-ok.mjs';
-
-const fromThrowable = (fn) => {
-  try {
-    return ok(fn());
-  } catch (error) {
-    if (isError(error)) {
-      return err(error);
+/**
+ * Wraps a function that may throw an exception in a `Result`.
+ *
+ * This is a fundamental utility for converting traditional exception-based
+ * error handling into Result-based error handling. Any thrown value is
+ * converted to an Error object for consistent error handling.
+ *
+ * If the function executes successfully, returns `Result.Ok` with the result.
+ * If the function throws, returns `Result.Err` with the caught error.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.fromThrowable(() => 1 + 1);
+ *
+ * const failure = Result.fromThrowable(() => {
+ *   throw new Error('boom');
+ * });
+ *
+ * assert.deepStrictEqual(success, Result.ok(2));
+ *
+ * assert.isTrue(Result.isErr(failure));
+ * ```
+ *
+ * @template T The return type of the function.
+ * @param fn The function to execute that may throw.
+ * @returns A `Result<T, Error>` containing either the successful result or
+ *   the caught error.
+ */
+export const fromThrowable = (fn) => {
+    try {
+        return ok(fn());
+    }
+    catch (error) {
+        if (isError(error)) {
+            return err(error);
+        }
+        const msg = unknownToString(error);
+        return err(new Error(msg));
     }
-    const msg = unknownToString(error);
-    return err(new Error(msg));
-  }
 };
-
-export { fromThrowable };
-//# sourceMappingURL=result-from-throwable.mjs.map
+//# sourceMappingURL=result-from-throwable.mjs.map

package/dist/functional/result/impl/result-from-throwable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-from-throwable.mjs","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"sourcesContent":["import { isError } from '@sindresorhus/is';\nimport { unknownToString } from '../../../others/index.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * Wraps a function that may throw an exception in a `Result`.\n *\n * This is a fundamental utility for converting traditional exception-based\n * error handling into Result-based error handling. Any thrown value is\n * converted to an Error object for consistent error handling.\n *\n * If the function executes successfully, returns `Result.Ok` with the result.\n * If the function throws, returns `Result.Err` with the caught error.\n *\n * @example\n *\n * ```ts\n * const success = Result.fromThrowable(() => 1 + 1);\n *\n * const failure = Result.fromThrowable(() => {\n *   throw new Error('boom');\n * });\n *\n * assert.deepStrictEqual(success, Result.ok(2));\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n *\n * @template T The return type of the function.\n * @param fn The function to execute that may throw.\n * @returns A `Result<T, Error>` containing either the successful result or\n *   the caught error.\n */\nexport const fromThrowable = <T,>(fn: () => T): Result<T, Error> => {\n  try {\n    return ok(fn());\n  } catch (error) {\n    if (isError(error)) {\n      return err(error);\n    }\n\n    const msg = unknownToString(error);\n\n    return err(new Error(msg));\n  }\n};\n"],"names":[],"mappings":";;;;;AAmCO,MAAM,aAAA,GAAgB,CAAK,EAAA,KAAkC;AAClE,EAAA,IAAI;AACF,IAAA,OAAO,EAAA,CAAG,IAAI,CAAA;AAAA,EAChB,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,OAAA,CAAQ,KAAK,CAAA,EAAG;AAClB,MAAA,OAAO,IAAI,KAAK,CAAA;AAAA,IAClB;AAEA,IAAA,MAAM,GAAA,GAAM,gBAAgB,KAAK,CAAA;AAEjC,IAAA,OAAO,GAAA,CAAI,IAAI,KAAA,CAAM,GAAG,CAAC,CAAA;AAAA,EAC3B;AACF;;;;"}
+{"version":3,"file":"result-from-throwable.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAK,EAAW,EAAoB,EAAE;IACjE,IAAI,CAAC;QACH,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;QAED,MAAM,GAAG,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;QAEnC,OAAO,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7B,CAAC;AACH,CAAC,CAAC"}

package/dist/functional/result/impl/result-is-err.mjs

@@ -1,6 +1,22 @@
 import { ErrTypeTagName } from './tag.mjs';
-
-const isErr = (result) => result.$$tag === ErrTypeTagName;
-
-export { isErr };
-//# sourceMappingURL=result-is-err.mjs.map
+/**
+ * Type guard for the error variant.
+ *
+ * @example
+ *
+ * ```ts
+ * const operation = Result.ok(3);
+ *
+ * const failure = Result.err('error');
+ *
+ * if (Result.isOk(operation)) {
+ *   const value: number = operation.value;
+ *
+ *   assert.isTrue(value === 3);
+ * }
+ *
+ * assert.isTrue(Result.isErr(failure));
+ * ```
+ */
+export const isErr = (result) => result.$$tag === ErrTypeTagName;
+//# sourceMappingURL=result-is-err.mjs.map

package/dist/functional/result/impl/result-is-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-is-err.mjs","sources":["../../../../src/functional/result/impl/result-is-err.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { ErrTypeTagName } from './tag.mjs';\nimport { type NarrowToErr } from './types.mjs';\n\n/**\n * Type guard for the error variant.\n *\n * @example\n *\n * ```ts\n * const operation = Result.ok(3);\n *\n * const failure = Result.err('error');\n *\n * if (Result.isOk(operation)) {\n *   const value: number = operation.value;\n *\n *   assert.isTrue(value === 3);\n * }\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n */\nexport const isErr = <R extends UnknownResult>(\n  result: R,\n): result is NarrowToErr<R> => result.$$tag === ErrTypeTagName;\n"],"names":[],"mappings":";;AAuBO,MAAM,KAAA,GAAQ,CACnB,MAAA,KAC6B,MAAA,CAAO,KAAA,KAAU;;;;"}
+{"version":3,"file":"result-is-err.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAG3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,MAAS,EACiB,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,cAAc,CAAC"}

package/dist/functional/result/impl/result-is-ok.mjs

@@ -1,6 +1,22 @@
 import { OkTypeTagName } from './tag.mjs';
-
-const isOk = (result) => result.$$tag === OkTypeTagName;
-
-export { isOk };
-//# sourceMappingURL=result-is-ok.mjs.map
+/**
+ * Type guard for the ok variant.
+ *
+ * @example
+ *
+ * ```ts
+ * const operation = Result.ok(3);
+ *
+ * const failure = Result.err('error');
+ *
+ * if (Result.isOk(operation)) {
+ *   const value: number = operation.value;
+ *
+ *   assert.isTrue(value === 3);
+ * }
+ *
+ * assert.isTrue(Result.isErr(failure));
+ * ```
+ */
+export const isOk = (result) => result.$$tag === OkTypeTagName;
+//# sourceMappingURL=result-is-ok.mjs.map

package/dist/functional/result/impl/result-is-ok.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-is-ok.mjs","sources":["../../../../src/functional/result/impl/result-is-ok.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { OkTypeTagName } from './tag.mjs';\nimport { type NarrowToOk } from './types.mjs';\n\n/**\n * Type guard for the ok variant.\n *\n * @example\n *\n * ```ts\n * const operation = Result.ok(3);\n *\n * const failure = Result.err('error');\n *\n * if (Result.isOk(operation)) {\n *   const value: number = operation.value;\n *\n *   assert.isTrue(value === 3);\n * }\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n */\nexport const isOk = <R extends UnknownResult>(\n  result: R,\n): result is NarrowToOk<R> => result.$$tag === OkTypeTagName;\n"],"names":[],"mappings":";;AAuBO,MAAM,IAAA,GAAO,CAClB,MAAA,KAC4B,MAAA,CAAO,KAAA,KAAU;;;;"}
+{"version":3,"file":"result-is-ok.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-ok.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,MAAS,EACgB,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,aAAa,CAAC"}

package/dist/functional/result/impl/result-is-result.mjs

@@ -1,8 +1,26 @@
-import { hasKey } from '../../../guard/has-key.mjs';
-import { isRecord } from '../../../guard/is-record.mjs';
+import { hasKey, isRecord } from '../../../guard/index.mjs';
 import { ErrTypeTagName, OkTypeTagName } from './tag.mjs';
-
-const isResult = (maybeResult) => isRecord(maybeResult) && hasKey(maybeResult, "$$tag") && hasKey(maybeResult, "value") && (maybeResult.$$tag === ErrTypeTagName || maybeResult.$$tag === OkTypeTagName);
-
-export { isResult };
-//# sourceMappingURL=result-is-result.mjs.map
+/**
+ * Checks whether the provided value is a {@link Result<S, E>}.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok('success');
+ *
+ * const errValue = Result.err(new Error('failure'));
+ *
+ * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;
+ *
+ * assert.isTrue(Result.isResult(okValue));
+ *
+ * assert.isTrue(Result.isResult(errValue));
+ *
+ * assert.isFalse(Result.isResult(notResult));
+ * ```
+ */
+export const isResult = (maybeResult) => isRecord(maybeResult) &&
+    hasKey(maybeResult, '$$tag') &&
+    hasKey(maybeResult, 'value') &&
+    (maybeResult.$$tag === ErrTypeTagName || maybeResult.$$tag === OkTypeTagName);
+//# sourceMappingURL=result-is-result.mjs.map

package/dist/functional/result/impl/result-is-result.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-is-result.mjs","sources":["../../../../src/functional/result/impl/result-is-result.mts"],"sourcesContent":["import { hasKey, isRecord } from '../../../guard/index.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { ErrTypeTagName, OkTypeTagName } from './tag.mjs';\n\n/**\n * Checks whether the provided value is a {@link Result<S, E>}.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok('success');\n *\n * const errValue = Result.err(new Error('failure'));\n *\n * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;\n *\n * assert.isTrue(Result.isResult(okValue));\n *\n * assert.isTrue(Result.isResult(errValue));\n *\n * assert.isFalse(Result.isResult(notResult));\n * ```\n */\nexport const isResult = (maybeResult: unknown): maybeResult is UnknownResult =>\n  isRecord(maybeResult) &&\n  hasKey(maybeResult, '$$tag') &&\n  hasKey(maybeResult, 'value') &&\n  (maybeResult.$$tag === ErrTypeTagName || maybeResult.$$tag === OkTypeTagName);\n"],"names":[],"mappings":";;;;AAuBO,MAAM,WAAW,CAAC,WAAA,KACvB,SAAS,WAAW,CAAA,IACpB,OAAO,WAAA,EAAa,OAAO,CAAA,IAC3B,MAAA,CAAO,aAAa,OAAO,CAAA,KAC1B,YAAY,KAAA,KAAU,cAAA,IAAkB,YAAY,KAAA,KAAU,aAAA;;;;"}
+{"version":3,"file":"result-is-result.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-is-result.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE5D,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,WAAoB,EAAgC,EAAE,CAC7E,QAAQ,CAAC,WAAW,CAAC;IACrB,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC;IAC5B,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC;IAC5B,CAAC,WAAW,CAAC,KAAK,KAAK,cAAc,IAAI,WAAW,CAAC,KAAK,KAAK,aAAa,CAAC,CAAC"}

package/dist/functional/result/impl/result-map-err.mjs

@@ -1,25 +1,22 @@
 import { err } from './result-err.mjs';
 import { isOk } from './result-is-ok.mjs';
-
-function mapErr(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, mapFn] = args;
-      return mapErrImpl(result, mapFn);
+export function mapErr(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, mapFn] = args;
+            return mapErrImpl(result, mapFn);
+        }
+        case 1: {
+            // Curried version: first argument is mapping function
+            const [mapFn] = args;
+            return (result) => mapErrImpl(result, mapFn);
+        }
     }
-    case 1: {
-      const [mapFn] = args;
-      return (result) => mapErrImpl(result, mapFn);
-    }
-  }
 }
-const mapErrImpl = (result, mapFn) => isOk(result) ? (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  result
-) : (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  err(mapFn(result.value))
-);
-
-export { mapErr };
-//# sourceMappingURL=result-map-err.mjs.map
+const mapErrImpl = (result, mapFn) => isOk(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        err(mapFn(result.value));
+//# sourceMappingURL=result-map-err.mjs.map

package/dist/functional/result/impl/result-map-err.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-map-err.mjs","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Maps a `Result<S, E>` to `Result<S, E2>` by applying a function to the\n * error value. If the `Result` is `Result.Ok`, returns the original `Ok`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(3) as Result<number, string>;\n *\n * const errValue = Result.err('missing');\n *\n * const untouchedOk = Result.mapErr(okValue, (error) => error.toUpperCase());\n *\n * const uppercasedErr = Result.mapErr(errValue, (error) =>\n *   error.toUpperCase(),\n * );\n *\n * assert.deepStrictEqual(untouchedOk, Result.ok(3));\n *\n * assert.deepStrictEqual(uppercasedErr, Result.err('MISSING'));\n *\n * const mapError = Result.mapErr((error: Readonly<Error>) => error.message);\n *\n * const wrapped = mapError(Result.err(new Error('boom')));\n *\n * assert.deepStrictEqual(wrapped, Result.err('boom'));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template E2 The type of the error value returned by the mapping function.\n * @param result The `Result` to map.\n * @param mapFn The function to apply to the error value if present.\n * @returns A new `Result<UnwrapOk<R>, E2>`.\n */\nexport function mapErr<R extends UnknownResult, E2>(\n  result: R,\n  mapFn: (error: UnwrapErr<R>) => E2,\n): Result<UnwrapOk<R>, E2>;\n\n// Curried version\n//\n// The returned function is generic over the *whole* result, mirroring the\n// direct overload above, rather than fixing its parameter to `Result<S, E>`.\n// Fixing it makes the curried form unusable from a caller that is itself\n// generic over the result: with `E` bound to `UnwrapErr<R>` at currying time the\n// parameter becomes `Result<...>` in terms of `R`, and TypeScript cannot show\n// a bare `R extends UnknownResult` is assignable to that — although every\n// concrete instantiation of `R` is.\n//\n// The conditional is what keeps the check: `R` is inferred from the argument\n// and its error type still has to satisfy `E`, so the mismatched case stays an\n// error. The cost is the message it produces — \"not assignable to `never`\"\n// rather than naming the two results.\nexport function mapErr<E, E2>(\n  mapFn: (error: E) => E2,\n): <R extends UnknownResult>(\n  result: UnwrapErr<R> extends E ? R : never,\n) => Result<UnwrapOk<R>, E2>;\n\nexport function mapErr<R extends UnknownResult, E2>(\n  ...args:\n    | readonly [result: R, mapFn: (error: UnwrapErr<R>) => E2]\n    | readonly [mapFn: (error: UnwrapErr<R>) => E2]\n): Result<UnwrapOk<R>, E2> | ((result: R) => Result<UnwrapOk<R>, E2>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, mapFn] = args;\n\n      return mapErrImpl(result, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (result: R) => mapErrImpl(result, mapFn);\n    }\n  }\n}\n\nconst mapErrImpl = <R extends UnknownResult, E2>(\n  result: R,\n  mapFn: (error: UnwrapErr<R>) => E2,\n): Result<UnwrapOk<R>, E2> =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (result as Ok<UnwrapOk<R>>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      err(mapFn(result.value as UnwrapErr<R>));\n"],"names":[],"mappings":";;;AAiEO,SAAS,UACX,IAAA,EAGiE;AACpE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,UAAA,CAAW,QAAQ,KAAK,CAAA;AAAA,IACjC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,UAAA,CAAW,MAAA,EAAQ,KAAK,CAAA;AAAA,IAChD;AAAA;AAEJ;AAEA,MAAM,UAAA,GAAa,CACjB,MAAA,EACA,KAAA,KAEA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEN;AAAA;AAAA;AAAA,EAED,GAAA,CAAI,KAAA,CAAM,MAAA,CAAO,KAAqB,CAAC;AAAA,CAAA;;;;"}
+{"version":3,"file":"result-map-err.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AA8D1C,MAAM,UAAU,MAAM,CACpB,GAAG,IAE8C;IAEjD,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE7B,OAAO,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACnC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,sDAAsD;YACtD,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,KAAkC,EACT,EAAE,CAC3B,IAAI,CAAC,MAAM,CAAC;IACV,CAAC,CAAC,oEAAoE;QACnE,MAA0B;IAC7B,CAAC,CAAC,oEAAoE;QACpE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC,CAAC"}

package/dist/functional/result/impl/result-map.mjs

@@ -1,25 +1,22 @@
 import { isErr } from './result-is-err.mjs';
 import { ok } from './result-ok.mjs';
-
-function map(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, mapFn] = args;
-      return mapImpl(result, mapFn);
+export function map(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, mapFn] = args;
+            return mapImpl(result, mapFn);
+        }
+        case 1: {
+            // Curried version
+            const [mapFn] = args;
+            return (result) => mapImpl(result, mapFn);
+        }
     }
-    case 1: {
-      const [mapFn] = args;
-      return (result) => mapImpl(result, mapFn);
-    }
-  }
 }
-const mapImpl = (result, mapFn) => isErr(result) ? (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  result
-) : (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  ok(mapFn(result.value))
-);
-
-export { map };
-//# sourceMappingURL=result-map.mjs.map
+const mapImpl = (result, mapFn) => isErr(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        ok(mapFn(result.value));
+//# sourceMappingURL=result-map.mjs.map

package/dist/functional/result/impl/result-map.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-map.mjs","sources":["../../../../src/functional/result/impl/result-map.mts"],"sourcesContent":["import { type Err } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { ok } from './result-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Maps a `Result<S, E>` to `Result<S2, E>` by applying a function to the\n * success value. If the `Result` is `Result.Err`, returns the original\n * `Err`.\n *\n * @example\n *\n * ```ts\n * const okNumber = Result.ok(5);\n *\n * const errMessage = Result.err('error');\n *\n * const doubled = Result.map(okNumber, (value) => value * 2);\n *\n * const untouchedError = Result.map(errMessage, (value: number) => value * 2);\n *\n * assert.deepStrictEqual(doubled, Result.ok(10));\n *\n * assert.deepStrictEqual(untouchedError, errMessage);\n *\n * const mapToLength = Result.map((text: string) => text.length);\n *\n * assert.deepStrictEqual(mapToLength(Result.ok('abc')), Result.ok(3));\n *\n * assert.deepStrictEqual(mapToLength(Result.err('bad')), Result.err('bad'));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type of the success value returned by the mapping\n *   function.\n * @param result The `Result` to map.\n * @param mapFn The function to apply to the success value if present.\n * @returns A new `Result<S2, UnwrapErr<R>>`.\n */\nexport function map<R extends UnknownResult, S2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n): Result<S2, UnwrapErr<R>>;\n\n// Curried version\n//\n// The returned function is generic over the *whole* result, mirroring the\n// direct overload above, rather than fixing its parameter to `Result<S, E>`.\n// Fixing it makes the curried form unusable from a caller that is itself\n// generic over the result: with `S` bound to `UnwrapOk<R>` at currying time the\n// parameter becomes `Result<...>` in terms of `R`, and TypeScript cannot show\n// a bare `R extends UnknownResult` is assignable to that — although every\n// concrete instantiation of `R` is.\n//\n// The conditional is what keeps the check: `R` is inferred from the argument\n// and its success type still has to satisfy `S`, so the mismatched case stays an\n// error. The cost is the message it produces — \"not assignable to `never`\"\n// rather than naming the two results.\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): <R extends UnknownResult>(\n  result: UnwrapOk<R> extends S ? R : never,\n) => Result<S2, UnwrapErr<R>>;\n\nexport function map<R extends UnknownResult, S2>(\n  ...args:\n    | readonly [result: R, mapFn: (value: UnwrapOk<R>) => S2]\n    | readonly [mapFn: (value: UnwrapOk<R>) => S2]\n): Result<S2, UnwrapErr<R>> | ((result: R) => Result<S2, UnwrapErr<R>>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, mapFn] = args;\n\n      return mapImpl(result, mapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [mapFn] = args;\n\n      return (result: R) => mapImpl(result, mapFn);\n    }\n  }\n}\n\nconst mapImpl = <R extends UnknownResult, S2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n): Result<S2, UnwrapErr<R>> =>\n  isErr(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (result as Err<UnwrapErr<R>>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ok(mapFn(result.value as UnwrapOk<R>));\n"],"names":[],"mappings":";;;AAiEO,SAAS,OACX,IAAA,EAGmE;AACtE,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,OAAA,CAAQ,QAAQ,KAAK,CAAA;AAAA,IAC9B;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,OAAA,CAAQ,MAAA,EAAQ,KAAK,CAAA;AAAA,IAC7C;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,CACd,MAAA,EACA,KAAA,KAEA,MAAM,MAAM,CAAA;AAAA;AAAA,EAEP;AAAA;AAAA;AAAA,EAED,EAAA,CAAG,KAAA,CAAM,MAAA,CAAO,KAAoB,CAAC;AAAA,CAAA;;;;"}
+{"version":3,"file":"result-map.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AA8DrC,MAAM,UAAU,GAAG,CACjB,GAAG,IAE6C;IAEhD,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE7B,OAAO,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAChC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,OAAO,GAAG,CACd,MAAS,EACT,KAAiC,EACP,EAAE,CAC5B,KAAK,CAAC,MAAM,CAAC;IACX,CAAC,CAAC,oEAAoE;QACnE,MAA4B;IAC/B,CAAC,CAAC,oEAAoE;QACpE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAoB,CAAC,CAAC,CAAC"}

package/dist/functional/result/impl/result-match.mjs

@@ -1,24 +1,20 @@
 import { isOk } from './result-is-ok.mjs';
-
-function match(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, cases] = args;
-      return matchImpl(result, cases);
+export function match(...args) {
+    switch (args.length) {
+        case 2: {
+            const [result, cases] = args;
+            return matchImpl(result, cases);
+        }
+        case 1: {
+            // Curried version: the only argument is the case handlers
+            const [cases] = args;
+            return (result) => matchImpl(result, cases);
+        }
     }
-    case 1: {
-      const [cases] = args;
-      return (result) => matchImpl(result, cases);
-    }
-  }
 }
-const matchImpl = (result, cases) => isOk(result) ? (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  cases.ok(result.value)
-) : (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  cases.err(result.value)
-);
-
-export { match };
-//# sourceMappingURL=result-match.mjs.map
+const matchImpl = (result, cases) => isOk(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        cases.ok(result.value)
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        cases.err(result.value);
+//# sourceMappingURL=result-match.mjs.map

package/dist/functional/result/impl/result-match.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-match.mjs","sources":["../../../../src/functional/result/impl/result-match.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Folds a `Result` into a plain value by applying one of two case handlers:\n * `ok` if the `Result` is `Ok`, `err` otherwise. This is the function form of\n * pattern matching on a `Result`.\n *\n * Unlike {@link Result.fold}, which maps both sides and returns another\n * `Result`, `match` unwraps: both branches produce the final value directly.\n *\n * @example\n *\n * ```ts\n * const doubledOrZero = Result.match(Result.ok(21), {\n *   ok: (value) => value * 2,\n *   err: () => 0,\n * });\n *\n * assert.deepStrictEqual(doubledOrZero, 42);\n *\n * const matcher = Result.match({\n *   ok: (value: number) => value + 1,\n *   err: (error: string) => error.length,\n * });\n *\n * assert.deepStrictEqual(matcher(Result.ok(1)), 2);\n *\n * assert.deepStrictEqual(matcher(Result.err('oops')), 4);\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type returned by the `ok` case.\n * @template E2 The type returned by the `err` case.\n * @param result The `Result` to match on.\n * @param cases An object with an `ok` handler receiving the success value and\n *   an `err` handler receiving the error value.\n * @returns The value produced by whichever case handler was applied.\n */\nexport function match<R extends UnknownResult, S2, E2>(\n  result: R,\n  cases: Readonly<{\n    ok: (value: UnwrapOk<R>) => S2;\n    err: (error: UnwrapErr<R>) => E2;\n  }>,\n): E2 | S2;\n\n// Curried version\n//\n// The returned function is generic over the *whole* result, mirroring the\n// direct overload above; see the comment on the curried overload of\n// `Result.map` for why the parameter is a conditional type instead of a plain\n// `Result<S, E>`. Both sides have to be checked here, hence the nested\n// conditional.\nexport function match<S, E, S2, E2>(\n  cases: Readonly<{\n    ok: (value: S) => S2;\n    err: (error: E) => E2;\n  }>,\n): <R extends UnknownResult>(\n  result: UnwrapOk<R> extends S ? (UnwrapErr<R> extends E ? R : never) : never,\n) => E2 | S2;\n\nexport function match<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [\n        result: R,\n        cases: Readonly<{\n          ok: (value: UnwrapOk<R>) => S2;\n          err: (error: UnwrapErr<R>) => E2;\n        }>,\n      ]\n    | readonly [\n        cases: Readonly<{\n          ok: (value: UnwrapOk<R>) => S2;\n          err: (error: UnwrapErr<R>) => E2;\n        }>,\n      ]\n): E2 | S2 | ((result: R) => E2 | S2) {\n  switch (args.length) {\n    case 2: {\n      const [result, cases] = args;\n\n      return matchImpl(result, cases);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the case handlers\n      const [cases] = args;\n\n      return (result: R) => matchImpl(result, cases);\n    }\n  }\n}\n\nconst matchImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  cases: Readonly<{\n    ok: (value: UnwrapOk<R>) => S2;\n    err: (error: UnwrapErr<R>) => E2;\n  }>,\n): E2 | S2 =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      cases.ok(result.value as UnwrapOk<R>)\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      cases.err(result.value as UnwrapErr<R>);\n"],"names":[],"mappings":";;AAgEO,SAAS,SACX,IAAA,EAciC;AACpC,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAK,CAAA,GAAI,IAAA;AAExB,MAAA,OAAO,SAAA,CAAU,QAAQ,KAAK,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,MAAA,KAAc,SAAA,CAAU,MAAA,EAAQ,KAAK,CAAA;AAAA,IAC/C;AAAA;AAEJ;AAEA,MAAM,SAAA,GAAY,CAChB,MAAA,EACA,KAAA,KAKA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEP,KAAA,CAAM,EAAA,CAAG,MAAA,CAAO,KAAoB;AAAA;AAAA;AAAA,EAEpC,KAAA,CAAM,GAAA,CAAI,MAAA,CAAO,KAAqB;AAAA,CAAA;;;;"}
+{"version":3,"file":"result-match.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-match.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AA+D1C,MAAM,UAAU,KAAK,CACnB,GAAG,IAaE;IAEL,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE7B,OAAO,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,0DAA0D;YAC1D,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,SAAS,GAAG,CAChB,MAAS,EACT,KAGE,EACO,EAAE,CACX,IAAI,CAAC,MAAM,CAAC;IACV,CAAC,CAAC,oEAAoE;QACpE,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,KAAoB,CAAC;IACvC,CAAC,CAAC,oEAAoE;QACpE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC"}

package/dist/functional/result/impl/result-ok.mjs

@@ -1,9 +1,31 @@
 import { OkTypeTagName } from './tag.mjs';
-
-const ok = (value) => ({
-  $$tag: OkTypeTagName,
-  value
+/**
+ * Creates a `Result.Ok` containing the given success value.
+ *
+ * Use this constructor when an operation succeeds and you want to wrap the
+ * successful result in a Result type for consistent error handling.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.ok({ id: 1 });
+ *
+ * const failure = Result.err(new Error('missing data'));
+ *
+ * assert.deepStrictEqual(success, {
+ *   $$tag: 'ts-data-forge::Result.ok',
+ *   value: { id: 1 },
+ * });
+ *
+ * assert.isTrue(Result.isErr(failure));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @param value The success value.
+ * @returns A `Result.Ok<S>` containing the value.
+ */
+export const ok = (value) => ({
+    $$tag: OkTypeTagName,
+    value,
 });
-
-export { ok };
-//# sourceMappingURL=result-ok.mjs.map
+//# sourceMappingURL=result-ok.mjs.map

package/dist/functional/result/impl/result-ok.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-ok.mjs","sources":["../../../../src/functional/result/impl/result-ok.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { OkTypeTagName } from './tag.mjs';\n\n/**\n * Creates a `Result.Ok` containing the given success value.\n *\n * Use this constructor when an operation succeeds and you want to wrap the\n * successful result in a Result type for consistent error handling.\n *\n * @example\n *\n * ```ts\n * const success = Result.ok({ id: 1 });\n *\n * const failure = Result.err(new Error('missing data'));\n *\n * assert.deepStrictEqual(success, {\n *   $$tag: 'ts-data-forge::Result.ok',\n *   value: { id: 1 },\n * });\n *\n * assert.isTrue(Result.isErr(failure));\n * ```\n *\n * @template S The type of the success value.\n * @param value The success value.\n * @returns A `Result.Ok<S>` containing the value.\n */\nexport const ok = <const S,>(value: S): Ok<S> =>\n  ({\n    $$tag: OkTypeTagName,\n    value,\n  }) as const;\n"],"names":[],"mappings":";;AA4BO,MAAM,EAAA,GAAK,CAAW,KAAA,MAC1B;AAAA,EACC,KAAA,EAAO,aAAA;AAAA,EACP;AACF,CAAA;;;;"}
+{"version":3,"file":"result-ok.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-ok.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,CAAW,KAAQ,EAAS,EAAE,CAC9C,CAAC;IACC,KAAK,EAAE,aAAa;IACpB,KAAK;CACN,CAAU,CAAC"}

package/dist/functional/result/impl/result-or-else.mjs

@@ -1,18 +1,17 @@
 import { isOk } from './result-is-ok.mjs';
-
-function orElse(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, alternative] = args;
-      return orElseImpl(result, alternative);
+export function orElse(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, alternative] = args;
+            return orElseImpl(result, alternative);
+        }
+        case 1: {
+            // Curried version
+            const [alternative] = args;
+            return (result) => orElseImpl(result, alternative);
+        }
     }
-    case 1: {
-      const [alternative] = args;
-      return (result) => orElseImpl(result, alternative);
-    }
-  }
 }
-const orElseImpl = (result, alternative) => isOk(result) ? result : alternative;
-
-export { orElse };
-//# sourceMappingURL=result-or-else.mjs.map
+const orElseImpl = (result, alternative) => (isOk(result) ? result : alternative);
+//# sourceMappingURL=result-or-else.mjs.map

package/dist/functional/result/impl/result-or-else.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-or-else.mjs","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { type NarrowToOk } from './types.mjs';\n\n/**\n * Returns the `Result` if it is `Ok`, otherwise returns the alternative.\n *\n * @example\n *\n * ```ts\n * const primary = Result.ok('primary');\n *\n * const fallback = Result.ok('fallback');\n *\n * const failure = Result.err('failure');\n *\n * assert.deepStrictEqual(Result.orElse(primary, fallback), primary);\n *\n * assert.deepStrictEqual(Result.orElse(failure, fallback), fallback);\n *\n * const orElseFallback = Result.orElse(Result.ok('default'));\n *\n * assert.deepStrictEqual(\n *   orElseFallback(Result.err('missing')),\n *   Result.ok('default'),\n * );\n *\n * assert.deepStrictEqual(\n *   orElseFallback(Result.ok('value')),\n *   Result.ok('value'),\n * );\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to check.\n * @param alternative The alternative `Result` to return if the first is\n *   `Err`.\n * @returns The first `Result` if `Ok`, otherwise the alternative.\n */\nexport function orElse<R extends UnknownResult, R2 extends UnknownResult>(\n  result: R,\n  alternative: R2,\n): NarrowToOk<R> | R2;\n\n// Curried version\nexport function orElse<R2 extends UnknownResult>(\n  alternative: R2,\n): <R extends UnknownResult>(result: R) => NarrowToOk<R> | R2;\n\nexport function orElse<R extends UnknownResult, R2 extends UnknownResult>(\n  ...args: readonly [result: R, alternative: R2] | readonly [alternative: R2]\n): (NarrowToOk<R> | R2) | ((result: R) => R | R2) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, alternative] = args;\n\n      return orElseImpl(result, alternative);\n    }\n\n    case 1: {\n      // Curried version\n      const [alternative] = args;\n\n      return (result: R) => orElseImpl(result, alternative);\n    }\n  }\n}\n\nconst orElseImpl = <R extends UnknownResult, R2 extends UnknownResult>(\n  result: R,\n  alternative: R2,\n): NarrowToOk<R> | R2 => (isOk(result) ? result : alternative);\n"],"names":[],"mappings":";;AAiDO,SAAS,UACX,IAAA,EAC6C;AAChD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,WAAW,CAAA,GAAI,IAAA;AAE9B,MAAA,OAAO,UAAA,CAAW,QAAQ,WAAW,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,WAAW,CAAA,GAAI,IAAA;AAEtB,MAAA,OAAO,CAAC,MAAA,KAAc,UAAA,CAAW,MAAA,EAAQ,WAAW,CAAA;AAAA,IACtD;AAAA;AAEJ;AAEA,MAAM,aAAa,CACjB,MAAA,EACA,gBACwB,IAAA,CAAK,MAAM,IAAI,MAAA,GAAS,WAAA;;;;"}
+{"version":3,"file":"result-or-else.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-or-else.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAgD1C,MAAM,UAAU,MAAM,CACpB,GAAG,IAAwE;IAE3E,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC;YAEnC,OAAO,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QACzC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;YAE3B,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,UAAU,GAAG,CACjB,MAAS,EACT,WAAe,EACK,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC"}

package/dist/functional/result/impl/result-safe-try.mjs

@@ -1,24 +1,35 @@
-import { hasKey } from '../../../guard/has-key.mjs';
-import { isRecord } from '../../../guard/is-record.mjs';
-
-function safeTry(body) {
-  const generator = body();
-  const step = generator.next();
-  if (isSyncStep(step)) {
-    if (step.done !== true && isSyncGenerator(generator, step)) {
-      generator.return(step.value);
+import { hasKey, isRecord } from '../../../guard/index.mjs';
+export function safeTry(body) {
+    const generator = body();
+    // A yielded `Err` and a returned `Result` are both already the final
+    // answer, so the first step's `value` is the result in either case: the
+    // generator is closed rather than resumed after yielding.
+    const step = generator.next();
+    if (isSyncStep(step)) {
+        // Dropping a suspended generator would skip the `finally` blocks and
+        // `using` disposals still pending in the body; closing it runs them
+        // before the short-circuited `Err` is handed back. `isSyncGenerator` is
+        // what makes `return()` here synchronous rather than a floating promise.
+        if (step.done !== true && isSyncGenerator(generator, step)) {
+            generator.return(step.value);
+        }
+        return step.value;
     }
-    return step.value;
-  }
-  return step.then(async (asyncStep) => {
-    if (asyncStep.done !== true) {
-      await generator.return(asyncStep.value);
-    }
-    return asyncStep.value;
-  });
+    return step.then(async (asyncStep) => {
+        if (asyncStep.done !== true) {
+            await generator.return(asyncStep.value);
+        }
+        return asyncStep.value;
+    });
 }
-const isSyncStep = (value) => isRecord(value) && hasKey(value, "done");
+// A sync generator's `next()` returns a plain `{ value, done }` object with
+// own properties, while an async generator's returns a `Promise`, whose
+// `then` lives on the prototype — so an own-key check on `done` separates the
+// two.
+const isSyncStep = (value) => isRecord(value) && hasKey(value, 'done');
+// The generator-side counterpart of `isSyncStep`: a step in the sync form can
+// only have come from a sync generator, so the step is what narrows the
+// generator that produced it — hence the predicate reads its second argument
+// and not its first.
 const isSyncGenerator = (_generator, step) => isSyncStep(step);
-
-export { safeTry };
-//# sourceMappingURL=result-safe-try.mjs.map
+//# sourceMappingURL=result-safe-try.mjs.map

package/dist/functional/result/impl/result-safe-try.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-safe-try.mjs","sources":["../../../../src/functional/result/impl/result-safe-try.mts"],"sourcesContent":["import { hasKey, isRecord } from '../../../guard/index.mjs';\nimport { type Err } from '../../../types.mjs';\nimport { type Result, type UnknownResult } from '../result.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Runs a generator body in which `yield* Result.safeUnwrap(...)` unwraps `Ok`\n * values and short-circuits on the first `Err`, emulating Rust's `?` operator\n * (early-return error propagation).\n *\n * The body must return a `Result`. If every unwrapped `Result` is `Ok`, the\n * returned value is the body's `Result`; otherwise it is the first `Err`\n * encountered, and the rest of the body never runs — though the generator is\n * closed rather than dropped, so `finally` blocks and `using` disposals\n * pending in the body still run. An exception thrown by the body is not\n * converted to an `Err`: it propagates out of `safeTry` (as a rejected\n * `Promise` for an async body). Use {@link Result.fromThrowable} for that.\n *\n * Passing an async generator (`async function*`) returns a\n * `Promise<Result<...>>` instead, so `await` can be used inside the body.\n * Note that `yield*` inside an `async function*` awaits what it receives, so\n * unwrapping an `Ok` whose value is itself a `Promise` yields the awaited\n * value there while the static type still says `Promise<...>`; keep promises\n * out of the `Ok` side of a `Result` unwrapped in an async body.\n *\n * @example\n *\n * ```ts\n * const parseTwo = (a: string, b: string): Result<number, Error> =>\n *   Result.safeTry(function* () {\n *     const x = yield* Result.safeUnwrap(Num.safeParseInt(a));\n *\n *     const y = yield* Result.safeUnwrap(Num.safeParseInt(b));\n *\n *     return Result.ok(x + y);\n *   });\n *\n * assert.deepStrictEqual(parseTwo('1', '2'), Result.ok(3));\n *\n * assert.isTrue(Result.isErr(parseTwo('1', 'not a number')));\n * ```\n *\n * @template Y The union of `Err` types unwrapped via\n *   {@link Result.safeUnwrap} (`never` if nothing is unwrapped).\n * @template R2 The `Result` type returned by the body.\n * @param body A generator function whose `yield*` expressions delegate to\n *   {@link Result.safeUnwrap} and whose return value is a `Result`.\n * @returns The body's `Result`, or the first `Err` short-circuited out of it\n *   (wrapped in a `Promise` for an async generator body).\n */\nexport function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(\n  body: () => Generator<Y, R2>,\n): Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>;\n\nexport function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(\n  body: () => AsyncGenerator<Y, R2>,\n): Promise<Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>>;\n\nexport function safeTry(\n  body:\n    | (() => AsyncGenerator<UnknownResult, UnknownResult>)\n    | (() => Generator<UnknownResult, UnknownResult>),\n): Promise<UnknownResult> | UnknownResult {\n  const generator = body();\n\n  // A yielded `Err` and a returned `Result` are both already the final\n  // answer, so the first step's `value` is the result in either case: the\n  // generator is closed rather than resumed after yielding.\n  const step = generator.next();\n\n  if (isSyncStep(step)) {\n    // Dropping a suspended generator would skip the `finally` blocks and\n    // `using` disposals still pending in the body; closing it runs them\n    // before the short-circuited `Err` is handed back. `isSyncGenerator` is\n    // what makes `return()` here synchronous rather than a floating promise.\n    if (step.done !== true && isSyncGenerator(generator, step)) {\n      generator.return(step.value);\n    }\n\n    return step.value;\n  }\n\n  return step.then(async (asyncStep) => {\n    if (asyncStep.done !== true) {\n      await generator.return(asyncStep.value);\n    }\n\n    return asyncStep.value;\n  });\n}\n\n// A sync generator's `next()` returns a plain `{ value, done }` object with\n// own properties, while an async generator's returns a `Promise`, whose\n// `then` lives on the prototype — so an own-key check on `done` separates the\n// two.\nconst isSyncStep = (\n  value: unknown,\n): value is IteratorResult<UnknownResult, UnknownResult> =>\n  isRecord(value) && hasKey(value, 'done');\n\n// The generator-side counterpart of `isSyncStep`: a step in the sync form can\n// only have come from a sync generator, so the step is what narrows the\n// generator that produced it — hence the predicate reads its second argument\n// and not its first.\nconst isSyncGenerator = (\n  _generator:\n    | AsyncGenerator<UnknownResult, UnknownResult>\n    | Generator<UnknownResult, UnknownResult>,\n  step: unknown,\n): _generator is Generator<UnknownResult, UnknownResult> => isSyncStep(step);\n"],"names":[],"mappings":";;;AA0DO,SAAS,QACd,IAAA,EAGwC;AACxC,EAAA,MAAM,YAAY,IAAA,EAAK;AAKvB,EAAA,MAAM,IAAA,GAAO,UAAU,IAAA,EAAK;AAE5B,EAAA,IAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AAKpB,IAAA,IAAI,KAAK,IAAA,KAAS,IAAA,IAAQ,eAAA,CAAgB,SAAA,EAAW,IAAI,CAAA,EAAG;AAC1D,MAAA,SAAA,CAAU,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,IAC7B;AAEA,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAEA,EAAA,OAAO,IAAA,CAAK,IAAA,CAAK,OAAO,SAAA,KAAc;AACpC,IAAA,IAAI,SAAA,CAAU,SAAS,IAAA,EAAM;AAC3B,MAAA,MAAM,SAAA,CAAU,MAAA,CAAO,SAAA,CAAU,KAAK,CAAA;AAAA,IACxC;AAEA,IAAA,OAAO,SAAA,CAAU,KAAA;AAAA,EACnB,CAAC,CAAA;AACH;AAMA,MAAM,UAAA,GAAa,CACjB,KAAA,KAEA,QAAA,CAAS,KAAK,CAAA,IAAK,MAAA,CAAO,OAAO,MAAM,CAAA;AAMzC,MAAM,eAAA,GAAkB,CACtB,UAAA,EAGA,IAAA,KAC0D,WAAW,IAAI,CAAA;;;;"}
+{"version":3,"file":"result-safe-try.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-safe-try.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AA0D5D,MAAM,UAAU,OAAO,CACrB,IAEmD;IAEnD,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC;IAEzB,qEAAqE;IACrE,wEAAwE;IACxE,0DAA0D;IAC1D,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAE9B,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,qEAAqE;QACrE,oEAAoE;QACpE,wEAAwE;QACxE,yEAAyE;QACzE,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,eAAe,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC;YAC3D,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;QACnC,IAAI,SAAS,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC5B,MAAM,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,SAAS,CAAC,KAAK,CAAC;IACzB,CAAC,CAAC,CAAC;AACL,CAAC;AAED,4EAA4E;AAC5E,wEAAwE;AACxE,8EAA8E;AAC9E,OAAO;AACP,MAAM,UAAU,GAAG,CACjB,KAAc,EACyC,EAAE,CACzD,QAAQ,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAE3C,8EAA8E;AAC9E,wEAAwE;AACxE,6EAA6E;AAC7E,qBAAqB;AACrB,MAAM,eAAe,GAAG,CACtB,UAE2C,EAC3C,IAAa,EAC0C,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC"}

package/dist/functional/result/impl/result-safe-unwrap.mjs

@@ -1,14 +1,42 @@
 import { isErr } from './result-is-err.mjs';
-
-function* safeUnwrap(result) {
-  if (isErr(result)) {
-    yield result;
-    throw new Error(
-      "`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`"
-    );
-  }
-  return result.value;
+/**
+ * Unwraps a `Result` inside a {@link Result.safeTry} generator body via
+ * `yield*`, emulating Rust's `?` operator.
+ *
+ * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained
+ * value and execution continues. If it is `Err`, the error is yielded to
+ * {@link Result.safeTry}, which returns it immediately — the rest of the
+ * generator body never runs.
+ *
+ * This generator must only be delegated to (`yield*`) inside a
+ * {@link Result.safeTry} body; resuming it after it has yielded an `Err`
+ * throws.
+ *
+ * @example
+ *
+ * ```ts
+ * const result = Result.safeTry(function* () {
+ *   const x = yield* Result.safeUnwrap(Result.ok(2));
+ *
+ *   const y = yield* Result.safeUnwrap(Result.ok(3));
+ *
+ *   return Result.ok(x + y);
+ * });
+ *
+ * assert.deepStrictEqual(result, Result.ok(5));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @param result The `Result` to unwrap.
+ * @returns A generator that yields the `Err` (if any) and returns the `Ok`
+ *   value.
+ */
+export function* safeUnwrap(result) {
+    if (isErr(result)) {
+        yield result;
+        throw new Error('`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`');
+    }
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return result.value;
 }
-
-export { safeUnwrap };
-//# sourceMappingURL=result-safe-unwrap.mjs.map
+//# sourceMappingURL=result-safe-unwrap.mjs.map

package/dist/functional/result/impl/result-safe-unwrap.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-safe-unwrap.mjs","sources":["../../../../src/functional/result/impl/result-safe-unwrap.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { isErr } from './result-is-err.mjs';\nimport { type NarrowToErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Unwraps a `Result` inside a {@link Result.safeTry} generator body via\n * `yield*`, emulating Rust's `?` operator.\n *\n * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained\n * value and execution continues. If it is `Err`, the error is yielded to\n * {@link Result.safeTry}, which returns it immediately — the rest of the\n * generator body never runs.\n *\n * This generator must only be delegated to (`yield*`) inside a\n * {@link Result.safeTry} body; resuming it after it has yielded an `Err`\n * throws.\n *\n * @example\n *\n * ```ts\n * const result = Result.safeTry(function* () {\n *   const x = yield* Result.safeUnwrap(Result.ok(2));\n *\n *   const y = yield* Result.safeUnwrap(Result.ok(3));\n *\n *   return Result.ok(x + y);\n * });\n *\n * assert.deepStrictEqual(result, Result.ok(5));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to unwrap.\n * @returns A generator that yields the `Err` (if any) and returns the `Ok`\n *   value.\n */\nexport function* safeUnwrap<R extends UnknownResult>(\n  result: R,\n): Generator<NarrowToErr<R>, UnwrapOk<R>, unknown> {\n  if (isErr(result)) {\n    yield result;\n\n    throw new Error(\n      '`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`',\n    );\n  }\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  return result.value as UnwrapOk<R>;\n}\n"],"names":[],"mappings":";;AAoCO,UAAU,WACf,MAAA,EACiD;AACjD,EAAA,IAAI,KAAA,CAAM,MAAM,CAAA,EAAG;AACjB,IAAA,MAAM,MAAA;AAEN,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KACF;AAAA,EACF;AAGA,EAAA,OAAO,MAAA,CAAO,KAAA;AAChB;;;;"}
+{"version":3,"file":"result-safe-unwrap.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-safe-unwrap.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,SAAS,CAAC,CAAC,UAAU,CACzB,MAAS;IAET,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QAClB,MAAM,MAAM,CAAC;QAEb,MAAM,IAAI,KAAK,CACb,oHAAoH,CACrH,CAAC;IACJ,CAAC;IAED,oEAAoE;IACpE,OAAO,MAAM,CAAC,KAAoB,CAAC;AACrC,CAAC"}