ts-data-forge 14.6.1 → 14.6.3

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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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';
+export function mapErr(...args) {
+    switch (args.length) {
+        case 2: {
 
-function mapErr(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, mapFn] = args;
-      return mapErrImpl(result, mapFn);
-    }
-    case 1: {
-      const [mapFn] = args;
-      return (result) => mapErrImpl(result, mapFn);
+            const [result, mapFn] = args;
+            return 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)
+    ?
+        result
+    :
+        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';
+export function map(...args) {
+    switch (args.length) {
+        case 2: {
 
-function map(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, mapFn] = args;
-      return mapImpl(result, mapFn);
-    }
-    case 1: {
-      const [mapFn] = args;
-      return (result) => mapImpl(result, mapFn);
+            const [result, mapFn] = args;
+            return 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)
+    ?
+        result
+    :
+        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';
+export function match(...args) {
+    switch (args.length) {
+        case 2: {
+            const [result, cases] = args;
+            return matchImpl(result, cases);
+        }
+        case 1: {
 
-function match(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, cases] = args;
-      return matchImpl(result, cases);
+            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)
+    ?
+        cases.ok(result.value)
+    :
+        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
-});
 
-export { ok };
-//# sourceMappingURL=result-ok.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const ok = (value) => ({
+    $$tag: OkTypeTagName,
+    value,
+});
+//# 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';
+export function orElse(...args) {
+    switch (args.length) {
+        case 2: {
 
-function orElse(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, alternative] = args;
-      return orElseImpl(result, alternative);
-    }
-    case 1: {
-      const [alternative] = args;
-      return (result) => orElseImpl(result, alternative);
+            const [result, alternative] = args;
+            return 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);
-    }
-    return step.value;
-  }
-  return step.then(async (asyncStep) => {
-    if (asyncStep.done !== true) {
-      await generator.return(asyncStep.value);
+import { hasKey, isRecord } from '../../../guard/index.mjs';
+export function safeTry(body) {
+    const generator = body();
+
+
+
+    const step = generator.next();
+    if (isSyncStep(step)) {
+
+
+
+
+        if (step.done !== true && isSyncGenerator(generator, step)) {
+            generator.return(step.value);
+        }
+        return step.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");
-const isSyncGenerator = (_generator, step) => isSyncStep(step);
 
-export { safeTry };
-//# sourceMappingURL=result-safe-try.mjs.map
+
+
+
+const isSyncStep = (value) => isRecord(value) && hasKey(value, 'done');
+
+
+
+
+const isSyncGenerator = (_generator, step) => isSyncStep(step);
+//# 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;
-}
 
-export { safeUnwrap };
-//# sourceMappingURL=result-safe-unwrap.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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()`');
+    }
+
+    return result.value;
+}
+//# 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"}

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

@@ -3,10 +3,25 @@ import { isOk } from './result-is-ok.mjs';
 import { ok } from './result-ok.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
 
-const swap = (result) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  isOk(result) ? err(unwrapOk(result)) : ok(result.value)
-);
 
-export { swap };
-//# sourceMappingURL=result-swap.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const swap = (result) => 
+
+isOk(result) ? err(unwrapOk(result)) : ok(result.value);
+//# sourceMappingURL=result-swap.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-swap.mjs","sources":["../../../../src/functional/result/impl/result-swap.mts"],"sourcesContent":["import { type Result, type UnknownResult } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { ok } from './result-ok.mjs';\nimport { unwrapOk } from './result-unwrap-ok.mjs';\nimport { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Swaps the success and error values of a `Result`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok('value');\n *\n * const errValue = Result.err('error');\n *\n * assert.deepStrictEqual(Result.swap(okValue), Result.err('value'));\n *\n * assert.deepStrictEqual(Result.swap(errValue), Result.ok('error'));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to swap.\n * @returns A new `Result` with success and error swapped.\n */\nexport const swap = <R extends UnknownResult>(\n  result: R,\n): Result<UnwrapErr<R>, UnwrapOk<R>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  isOk(result) ? err(unwrapOk(result)) : ok(result.value as UnwrapErr<R>);\n"],"names":[],"mappings":";;;;;AA0BO,MAAM,OAAO,CAClB,MAAA;AAAA;AAAA,EAGA,IAAA,CAAK,MAAM,CAAA,GAAI,GAAA,CAAI,QAAA,CAAS,MAAM,CAAC,CAAA,GAAI,EAAA,CAAG,MAAA,CAAO,KAAqB;AAAA;;;;"}
+{"version":3,"file":"result-swap.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-swap.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,MAAS,EAC0B,EAAE;AACrC,oEAAoE;AACpE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC"}

package/dist/functional/result/impl/result-to-optional.mjs

@@ -1,9 +1,32 @@
-import { none } from '../../optional/impl/optional-none.mjs';
-import { some } from '../../optional/impl/optional-some.mjs';
+import { Optional } from '../../optional/index.mjs';
 import { isOk } from './result-is-ok.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
 
-const toOptional = (result) => isOk(result) ? some(unwrapOk(result)) : none;
 
-export { toOptional };
-//# sourceMappingURL=result-to-optional.mjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const toOptional = (result) => isOk(result) ? Optional.some(unwrapOk(result)) : Optional.none;
+//# sourceMappingURL=result-to-optional.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-to-optional.mjs","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"sourcesContent":["import { Optional } from '../../optional/index.mjs';\nimport { type UnknownResult } from '../result.mjs';\nimport { isOk } from './result-is-ok.mjs';\nimport { unwrapOk } from './result-unwrap-ok.mjs';\nimport { type UnwrapOk } from './types.mjs';\n\n/**\n * Converts a `Result` to an `Optional`.\n *\n * This conversion is useful when you want to discard error information and\n * only care about whether an operation succeeded. The error information is\n * lost in this conversion, so use it when error details are not needed.\n *\n * If the `Result` is `Ok`, returns `Some` with the value. If the `Result` is\n * `Err`, returns `None`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(7);\n *\n * const errValue = Result.err('fail');\n *\n * assert.deepStrictEqual(Result.toOptional(okValue), Optional.some(7));\n *\n * assert.deepStrictEqual(Result.toOptional(errValue), Optional.none);\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @param result The `Result` to convert.\n * @returns An `Optional<UnwrapOk<R>>` containing the success value or\n *   representing `None`.\n */\nexport const toOptional = <R extends UnknownResult>(\n  result: R,\n): Optional<UnwrapOk<R>> =>\n  isOk(result) ? Optional.some(unwrapOk(result)) : Optional.none;\n"],"names":["Optional.some","Optional.none"],"mappings":";;;;;AAiCO,MAAM,UAAA,GAAa,CACxB,MAAA,KAEA,IAAA,CAAK,MAAM,CAAA,GAAIA,IAAS,CAAK,QAAA,CAAS,MAAM,CAAC,CAAA,GAAIC;;;;"}
+{"version":3,"file":"result-to-optional.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-to-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,MAAS,EACc,EAAE,CACzB,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC"}

package/dist/functional/result/impl/result-unwrap-err-or.mjs

@@ -1,18 +1,17 @@
 import { unwrapErr } from './result-unwrap-err.mjs';
+export function unwrapErrOr(...args) {
+    switch (args.length) {
+        case 2: {
 
-function unwrapErrOr(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, defaultValue] = args;
-      return unwrapErrOrImpl(result, defaultValue);
-    }
-    case 1: {
-      const [defaultValue] = args;
-      return (result) => unwrapErrOrImpl(result, defaultValue);
+            const [result, defaultValue] = args;
+            return unwrapErrOrImpl(result, defaultValue);
+        }
+        case 1: {
+
+            const [defaultValue] = args;
+            return (result) => unwrapErrOrImpl(result, defaultValue);
+        }
     }
-  }
 }
 const unwrapErrOrImpl = (result, defaultValue) => unwrapErr(result) ?? defaultValue;
-
-export { unwrapErrOr };
-//# sourceMappingURL=result-unwrap-err-or.mjs.map
+//# sourceMappingURL=result-unwrap-err-or.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-unwrap-err-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"sourcesContent":["import { type UnknownResult } from '../result.mjs';\nimport { unwrapErr } from './result-unwrap-err.mjs';\nimport { type UnwrapErr } from './types.mjs';\n\n/**\n * Unwraps a `Result`, returning the error value or a default value if it is\n * `Result.Ok`.\n *\n * @example\n *\n * ```ts\n * const okResult = Result.ok('success');\n *\n * const errResult = Result.err('failure');\n *\n * assert.isTrue(Result.unwrapErrOr(okResult, 'default') === 'default');\n *\n * assert.isTrue(Result.unwrapErrOr(errResult, 'default') === 'failure');\n *\n * const unwrapError = Result.unwrapErrOr('fallback error');\n *\n * assert.isTrue(unwrapError(Result.err('boom')) === 'boom');\n *\n * assert.isTrue(unwrapError(Result.ok('no error')) === 'fallback error');\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @template D The type of the default value.\n * @param result The `Result` to unwrap.\n * @param defaultValue The value to return if `result` is `Result.Ok`.\n * @returns The error value if `Result.Err`, otherwise `defaultValue`.\n */\nexport function unwrapErrOr<R extends UnknownResult, D>(\n  result: R,\n  defaultValue: D,\n): D | UnwrapErr<R>;\n\n// Curried version\nexport function unwrapErrOr<D>(\n  defaultValue: D,\n): <R extends UnknownResult>(result: R) => D | UnwrapErr<R>;\n\nexport function unwrapErrOr<R extends UnknownResult, D>(\n  ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]\n): D | UnwrapErr<R> | ((result: R) => D | UnwrapErr<R>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, defaultValue] = args;\n\n      return unwrapErrOrImpl(result, defaultValue);\n    }\n\n    case 1: {\n      // Curried version\n      const [defaultValue] = args;\n\n      return (result: R) => unwrapErrOrImpl(result, defaultValue);\n    }\n  }\n}\n\nconst unwrapErrOrImpl = <R extends UnknownResult, D>(\n  result: R,\n  defaultValue: D,\n): D | UnwrapErr<R> => unwrapErr(result) ?? defaultValue;\n"],"names":[],"mappings":";;AA0CO,SAAS,eACX,IAAA,EACmD;AACtD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,YAAY,CAAA,GAAI,IAAA;AAE/B,MAAA,OAAO,eAAA,CAAgB,QAAQ,YAAY,CAAA;AAAA,IAC7C;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,YAAY,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,CAAC,MAAA,KAAc,eAAA,CAAgB,MAAA,EAAQ,YAAY,CAAA;AAAA,IAC5D;AAAA;AAEJ;AAEA,MAAM,kBAAkB,CACtB,MAAA,EACA,YAAA,KACqB,SAAA,CAAU,MAAM,CAAA,IAAK,YAAA;;;;"}
+{"version":3,"file":"result-unwrap-err-or.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err-or.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAyCpD,MAAM,UAAU,WAAW,CACzB,GAAG,IAAwE;IAE3E,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI,CAAC;YAEpC,OAAO,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC/C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;YAE5B,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,eAAe,GAAG,CACtB,MAAS,EACT,YAAe,EACG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC"}