ts-data-forge 14.6.0 → 14.6.2

package/dist/functional/optional/impl/optional-zip.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional-zip.mjs","sources":["../../../../src/functional/optional/impl/optional-zip.mts"],"sourcesContent":["import { type Optional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\n\n/**\n * Combines two `Optional` values into a single `Optional` containing a tuple.\n * If either `Optional` is `None`, returns `None`.\n *\n * @example\n *\n * ```ts\n * const zipped = Optional.zip(Optional.some('left'), Optional.some(1));\n *\n * assert.isTrue(Optional.isSome(zipped));\n *\n * if (Optional.isSome(zipped)) {\n *   const expected: readonly [string, number] = ['left', 1] as const;\n *\n *   assert.deepStrictEqual(zipped.value, expected);\n * }\n *\n * const missing = Optional.zip(\n *   Optional.some('value'),\n *   // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n *   Optional.none as Optional<number>,\n * );\n *\n * assert.deepStrictEqual(missing, Optional.none);\n * ```\n *\n * @template A The value type of the first `Optional`.\n * @template B The value type of the second `Optional`.\n * @param optionalA The first `Optional`.\n * @param optionalB The second `Optional`.\n * @returns An `Optional` containing a tuple of both values, or `None`.\n */\nexport const zip = <A, const B>(\n  optionalA: Optional<A>,\n  optionalB: Optional<B>,\n): Optional<readonly [A, B]> =>\n  isSome(optionalA) && isSome(optionalB)\n    ? some([optionalA.value, optionalB.value] as const)\n    : none;\n"],"names":[],"mappings":";;;;AAqCO,MAAM,MAAM,CACjB,SAAA,EACA,SAAA,KAEA,MAAA,CAAO,SAAS,CAAA,IAAK,MAAA,CAAO,SAAS,CAAA,GACjC,KAAK,CAAC,SAAA,CAAU,OAAO,SAAA,CAAU,KAAK,CAAU,CAAA,GAChD;;;;"}
+{"version":3,"file":"optional-zip.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-zip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACjB,SAAsB,EACtB,SAAsB,EACK,EAAE,CAC7B,MAAM,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC;IACpC,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAU,CAAC;IACnD,CAAC,CAAC,IAAI,CAAC"}

package/dist/functional/optional/impl/tag.mjs

@@ -1,5 +1,4 @@
-const SomeTypeTagName = "ts-data-forge::Optional.some";
-const NoneTypeTagName = "ts-data-forge::Optional.none";
-
-export { NoneTypeTagName, SomeTypeTagName };
-//# sourceMappingURL=tag.mjs.map
+export const SomeTypeTagName = 'ts-data-forge::Optional.some';
+/** @internal String literal tag to identify the 'None' variant of Optional. */
+export const NoneTypeTagName = 'ts-data-forge::Optional.none';
+//# sourceMappingURL=tag.mjs.map

package/dist/functional/optional/impl/tag.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/optional/impl/tag.mts"],"sourcesContent":["/** @internal String literal tag to identify the 'Some' variant of Optional. */\nimport { type None, type Some } from '../../../types.mjs';\n\nexport const SomeTypeTagName: Some<unknown>['$$tag'] =\n  'ts-data-forge::Optional.some';\n\n/** @internal String literal tag to identify the 'None' variant of Optional. */\nexport const NoneTypeTagName: None['$$tag'] = 'ts-data-forge::Optional.none';\n"],"names":[],"mappings":"AAGO,MAAM,eAAA,GACX;AAGK,MAAM,eAAA,GAAiC;;;;"}
+{"version":3,"file":"tag.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/tag.mts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,eAAe,GAC1B,8BAA8B,CAAC;AAEjC,+EAA+E;AAC/E,MAAM,CAAC,MAAM,eAAe,GAAkB,8BAA8B,CAAC"}

package/dist/functional/optional/impl/types.mjs

@@ -1,2 +1,2 @@
-
-//# sourceMappingURL=types.mjs.map
+export {};
+//# sourceMappingURL=types.mjs.map

package/dist/functional/optional/impl/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../../../src/functional/optional/impl/types.mts"],"names":[],"mappings":""}

package/dist/functional/optional/index.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as Optional };
-//# sourceMappingURL=index.mjs.map
+export * from './optional.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functional/optional/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/functional/optional/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/functional/optional/optional.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as Optional };
-//# sourceMappingURL=optional.mjs.map
+export * as Optional from './impl/index.mjs';
+//# sourceMappingURL=optional.mjs.map

package/dist/functional/optional/optional.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"optional.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"optional.mjs","sourceRoot":"","sources":["../../../src/functional/optional/optional.mts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC"}

package/dist/functional/pipe.mjs

@@ -1,17 +1,45 @@
-import { isOptional } from './optional/impl/optional-is-optional.mjs';
-import { map } from './optional/impl/optional-map.mjs';
 
-const pipe = (a) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  {
+import { Optional } from './optional/index.mjs';
+/**
+ * Creates a new pipe object that allows for chaining operations on a value.
+ *
+ * This function provides a fluent interface for applying transformations to
+ * values, with intelligent method selection based on the input type:
+ *
+ * - For `Optional` values: Provides `mapOptional` for safe Optional
+ *   transformations
+ * - For other values: Provides `mapNullable` for null-safe transformations
+ * - All types get the basic `map` method for general transformations
+ *
+ * The pipe maintains type safety throughout the chain, automatically selecting
+ * the appropriate overload based on the current value type.
+ *
+ * @template A The type of the initial value to wrap in a pipe.
+ * @param a The initial value to wrap in a pipe.
+ * @returns A pipe object with chaining methods appropriate for the value type.
+ */
+export const pipe = (a) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+({
     value: a,
     map: (fn) => pipe(fn(a)),
-    mapNullable: (fn) => pipe(a == null ? void 0 : fn(a)),
-    ...isOptional(a) ? {
-      mapOptional: (fn) => pipe(map(a, fn))
-    } : {}
-  }
-);
-
-export { pipe };
-//# sourceMappingURL=pipe.mjs.map
+    mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
+    ...(Optional.isOptional(a)
+        ? {
+            mapOptional: (fn) => pipe(Optional.map(a, fn)),
+        }
+        : {}),
+});
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=pipe.mjs.map

package/dist/functional/pipe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":["import { expectType } from '../expect-type.mjs';\nimport { Optional, type UnknownOptional } from './optional/index.mjs';\n\n/**\n * Creates a new pipe object that allows for chaining operations on a value.\n *\n * This function provides a fluent interface for applying transformations to\n * values, with intelligent method selection based on the input type:\n *\n * - For `Optional` values: Provides `mapOptional` for safe Optional\n *   transformations\n * - For other values: Provides `mapNullable` for null-safe transformations\n * - All types get the basic `map` method for general transformations\n *\n * The pipe maintains type safety throughout the chain, automatically selecting\n * the appropriate overload based on the current value type.\n *\n * @template A The type of the initial value to wrap in a pipe.\n * @param a The initial value to wrap in a pipe.\n * @returns A pipe object with chaining methods appropriate for the value type.\n */\nexport const pipe = <const A,>(a: A): Pipe<A> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  ({\n    value: a,\n    map: (fn) => pipe(fn(a)),\n    mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),\n\n    ...(Optional.isOptional(a)\n      ? {\n          mapOptional: (fn) => pipe(Optional.map(a, fn)),\n        }\n      : {}),\n  }) satisfies PipeImpl<A> as unknown as Pipe<A>;\n\n// `PipeBase<A>` is always present; the conditional only *adds* `mapOptional`\n// for Optional values. Two subtleties motivate this shape:\n//\n//   1. The check is `[A] extends [UnknownOptional]` (a 1-tuple), not the bare\n//      `A extends UnknownOptional`. A bare check distributes over unions, so a\n//      piped union value such as `Result<D, E> | undefined` would expand into\n//      `Pipe<Ok<D>> | Pipe<Err<E>> | Pipe<undefined>`. Calling a chained method\n//      on that union of pipe objects forces TypeScript to synthesize a merged\n//      call signature, during which a branded member like `Ok<D>` is widened to\n//      its constraint (`Ok<number>`) — losing the brand `D`.\n//\n//   2. `value: A` lives on `PipeBase<A>`, *outside* the conditional. If `value`\n//      flowed through the conditional, then for a not-yet-resolved generic `A`\n//      the deferred true branch narrows `A` to `A & UnknownOptional`, so\n//      `.value` would surface as the noisy `(A & UnknownOptional) | A`. Keeping\n//      it on the unconditional base yields a clean `A`.\nexport type Pipe<A> = PipeBase<A> &\n  PipeMapNullable<A> &\n  ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown);\n\n// NOTE: 以下では 'typing when used with generics' test で型エラーが出る。\n// 詳細は documents/reports/pipe-typing.md の 「mapNullable を条件付きで含めるのがうまくいかない理由」を参照。\n// export type Pipe<A> = PipeBase<A> &\n//   ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown) &\n//   ([undefined] extends [A] ? PipeMapNullable<A> : unknown) &\n//   ([null] extends [A] ? PipeMapNullable<A> : unknown);\n\nexpectType<Optional<number>, UnknownOptional>('<=');\n\nexpectType<number | undefined, undefined>('>=');\n\nexpectType<keyof Pipe<number | undefined>, 'value' | 'map' | 'mapNullable'>(\n  '=',\n);\n\nexpectType<\n  keyof Pipe<Optional<number>>,\n  'value' | 'map' | 'mapNullable' | 'mapOptional'\n>('=');\n\nexpectType<\n  keyof Pipe<Optional<number | undefined>>,\n  'value' | 'map' | 'mapNullable' | 'mapOptional'\n>('=');\n\nexpectType<\n  keyof Pipe<Optional<number> | undefined>,\n  'value' | 'map' | 'mapNullable'\n>('=');\n\ntype PipeBase<A> = Readonly<{\n  /** The current value being piped. */\n  value: A;\n\n  /**\n   * Maps the current value to a new value using the provided function.\n   *\n   * @example\n   *\n   * ```ts\n   * const result = pipe(2)\n   *   .map((value) => value * 3)\n   *   .map((value) => `value: ${value}`);\n   *\n   * assert.deepStrictEqual(result.value, 'value: 6');\n   * ```\n   *\n   * @template B The type of the new value.\n   * @param fn Function to transform the current value.\n   * @returns A new pipe containing the transformed value.\n   */\n  map: <B>(fn: (a: A) => B) => Pipe<B>;\n}>;\n\ntype PipeMapNullable<A> = Readonly<{\n  /**\n   * Maps the current value only if it's not null or undefined. If the current\n   * value is null/undefined, the transformation is skipped and undefined is\n   * propagated through the pipe.\n   *\n   * @example\n   *\n   * ```ts\n   * const result = pipe<string | undefined>('hello')\n   *   .mapNullable((value) => value.toUpperCase())\n   *   .mapNullable((value) => value.slice(0, 2));\n   *\n   * assert.deepStrictEqual(result.value, 'HE');\n   *\n   * const empty = pipe<string | undefined>(undefined).mapNullable((value) =>\n   *   value.toUpperCase(),\n   * );\n   *\n   * assert.isTrue(empty.value === undefined);\n   * ```\n   *\n   * @template B The type of the transformed value.\n   * @param fn Function to transform the non-null value.\n   * @returns A new pipe containing the transformed value or undefined.\n   */\n  mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;\n}>;\n\ntype PipeMapOptional<A extends UnknownOptional> = Readonly<{\n  /**\n   * Maps the value inside an Optional using Optional.map semantics. If the\n   * Optional is None, the transformation is skipped and None is propagated.\n   * If the Optional is Some, the transformation is applied to the inner\n   * value.\n   *\n   * @example\n   *\n   * ```ts\n   * const result = pipe(Optional.some(10))\n   *   .mapOptional((value) => value * 2)\n   *   .mapOptional((value) => value + 5);\n   *\n   * assert.deepStrictEqual(result.value, Optional.some(25));\n   *\n   * const empty = pipe(Optional.none as Optional<number>).mapOptional(\n   *   (value) => value * 2,\n   * );\n   *\n   * assert.isTrue(Optional.isNone(empty.value));\n   * ```\n   *\n   * @template B The type of the transformed inner value.\n   * @param fn Function to transform the inner value of the Optional.\n   * @returns A new pipe containing an Optional with the transformed value.\n   */\n  mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;\n}>;\n\n/** @internal */\ntype Cast<T, U> = T & U;\n\n/** @internal */\ntype PipeImpl<A> = Readonly<{\n  value: A;\n  map: <B>(fn: (a: A) => B) => PipeImpl<B>;\n  mapNullable?: <B>(fn: (a: NonNullable<A>) => B) => PipeImpl<B | undefined>;\n  mapOptional?: <B>(\n    fn: (a: Optional.Unwrap<Cast<A, UnknownOptional>>) => B,\n  ) => PipeImpl<Optional<B>>;\n}>;\n"],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AAqBO,MAAM,OAAO,CAAW,CAAA;AAAA;AAAA,EAE5B;AAAA,IACC,KAAA,EAAO,CAAA;AAAA,IACP,KAAK,CAAC,EAAA,KAAO,IAAA,CAAK,EAAA,CAAG,CAAC,CAAC,CAAA;AAAA,IACvB,WAAA,EAAa,CAAC,EAAA,KAAO,IAAA,CAAK,KAAK,IAAA,GAAO,MAAA,GAAY,EAAA,CAAG,CAAC,CAAC,CAAA;AAAA,IAEvD,GAAIA,UAAS,CAAW,CAAC,CAAA,GACrB;AAAA,MACE,WAAA,EAAa,CAAC,EAAA,KAAO,IAAA,CAAKC,GAAS,CAAI,CAAA,EAAG,EAAE,CAAC;AAAA,QAE/C;AAAC;AACP;;;;"}
+{"version":3,"file":"pipe.mjs","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAwB,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAW,CAAI,EAAW,EAAE;AAC9C,oEAAoE;AACpE,CAAC;IACC,KAAK,EAAE,CAAC;IACR,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACxB,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAExD,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;QACxB,CAAC,CAAC;YACE,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;QACH,CAAC,CAAC,EAAE,CAAC;CACR,CAA6C,CAAC;AAsBjD,6DAA6D;AAC7D,gFAAgF;AAChF,sCAAsC;AACtC,qEAAqE;AACrE,+DAA+D;AAC/D,yDAAyD;AAEzD,UAAU,CAAoC,IAAI,CAAC,CAAC;AAEpD,UAAU,CAAgC,IAAI,CAAC,CAAC;AAEhD,UAAU,CACR,GAAG,CACJ,CAAC;AAEF,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAGR,GAAG,CAAC,CAAC;AAEP,UAAU,CAGR,GAAG,CAAC,CAAC"}

package/dist/functional/result/impl/index.mjs

@@ -1,27 +1,28 @@
-export { err } from './result-err.mjs';
-export { expectToBe } from './result-expect-to-be.mjs';
-export { flatMap } from './result-flat-map.mjs';
-export { fold } from './result-fold.mjs';
-export { fromOptional } from './result-from-optional.mjs';
-export { fromPromise } from './result-from-promise.mjs';
-export { fromThrowable } from './result-from-throwable.mjs';
-export { isErr } from './result-is-err.mjs';
-export { isOk } from './result-is-ok.mjs';
-export { isResult } from './result-is-result.mjs';
-export { mapErr } from './result-map-err.mjs';
-export { map } from './result-map.mjs';
-export { match } from './result-match.mjs';
-export { ok } from './result-ok.mjs';
-export { orElse } from './result-or-else.mjs';
-export { safeTry } from './result-safe-try.mjs';
-export { safeUnwrap } from './result-safe-unwrap.mjs';
-export { swap } from './result-swap.mjs';
-export { toOptional } from './result-to-optional.mjs';
-export { unwrapErrOr } from './result-unwrap-err-or.mjs';
-export { unwrapErrThrow } from './result-unwrap-err-throw.mjs';
-export { unwrapErr } from './result-unwrap-err.mjs';
-export { unwrapOkOr } from './result-unwrap-ok-or.mjs';
-export { unwrapOk } from './result-unwrap-ok.mjs';
-export { unwrapThrow } from './result-unwrap-throw.mjs';
-export { zip } from './result-zip.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './result-err.mjs';
+export * from './result-expect-to-be.mjs';
+export * from './result-flat-map.mjs';
+export * from './result-fold.mjs';
+export * from './result-from-optional.mjs';
+export * from './result-from-promise.mjs';
+export * from './result-from-throwable.mjs';
+export * from './result-is-err.mjs';
+export * from './result-is-ok.mjs';
+export * from './result-is-result.mjs';
+export * from './result-map-err.mjs';
+export * from './result-map.mjs';
+export * from './result-match.mjs';
+export * from './result-ok.mjs';
+export * from './result-or-else.mjs';
+export * from './result-safe-try.mjs';
+export * from './result-safe-unwrap.mjs';
+export * from './result-swap.mjs';
+export * from './result-to-optional.mjs';
+export * from './result-unwrap-err-or.mjs';
+export * from './result-unwrap-err-throw.mjs';
+export * from './result-unwrap-err.mjs';
+export * from './result-unwrap-ok-or.mjs';
+export * from './result-unwrap-ok.mjs';
+export * from './result-unwrap-throw.mjs';
+export * from './result-zip.mjs';
+export * from './types.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

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

@@ -1,9 +1,31 @@
 import { ErrTypeTagName } from './tag.mjs';
-
-const err = (value) => ({
-  $$tag: ErrTypeTagName,
-  value
+/**
+ * Creates a `Result.Err` containing the given error value.
+ *
+ * Use this constructor when an operation fails and you want to wrap the error
+ * information 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 E The type of the error value.
+ * @param value The error value.
+ * @returns A `Result.Err<E>` containing the value.
+ */
+export const err = (value) => ({
+    $$tag: ErrTypeTagName,
+    value,
 });
-
-export { err };
-//# sourceMappingURL=result-err.mjs.map
+//# sourceMappingURL=result-err.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-err.mjs","sources":["../../../../src/functional/result/impl/result-err.mts"],"sourcesContent":["import { type Err } from '../../../types.mjs';\nimport { ErrTypeTagName } from './tag.mjs';\n\n/**\n * Creates a `Result.Err` containing the given error value.\n *\n * Use this constructor when an operation fails and you want to wrap the error\n * information 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 E The type of the error value.\n * @param value The error value.\n * @returns A `Result.Err<E>` containing the value.\n */\nexport const err = <const E,>(value: E): Err<E> =>\n  ({\n    $$tag: ErrTypeTagName,\n    value,\n  }) as const;\n"],"names":[],"mappings":";;AA4BO,MAAM,GAAA,GAAM,CAAW,KAAA,MAC3B;AAAA,EACC,KAAA,EAAO,cAAA;AAAA,EACP;AACF,CAAA;;;;"}
+{"version":3,"file":"result-err.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAW,KAAQ,EAAU,EAAE,CAChD,CAAC;IACC,KAAK,EAAE,cAAc;IACrB,KAAK;CACN,CAAU,CAAC"}

package/dist/functional/result/impl/result-expect-to-be.mjs

@@ -1,24 +1,23 @@
 import { isOk } from './result-is-ok.mjs';
 import { unwrapOk } from './result-unwrap-ok.mjs';
-
-function expectToBe(...args) {
-  switch (args.length) {
-    case 2: {
-      const [result, message] = args;
-      return expectToBeImpl(result, message);
+export function expectToBe(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, message] = args;
+            return expectToBeImpl(result, message);
+        }
+        case 1: {
+            // Curried version: first argument is message
+            const [message] = args;
+            return (result) => expectToBeImpl(result, message);
+        }
     }
-    case 1: {
-      const [message] = args;
-      return (result) => expectToBeImpl(result, message);
-    }
-  }
 }
 const expectToBeImpl = (result, message) => {
-  if (isOk(result)) {
-    return unwrapOk(result);
-  }
-  throw new Error(message);
+    if (isOk(result)) {
+        return unwrapOk(result);
+    }
+    throw new Error(message);
 };
-
-export { expectToBe };
-//# sourceMappingURL=result-expect-to-be.mjs.map
+//# sourceMappingURL=result-expect-to-be.mjs.map

package/dist/functional/result/impl/result-expect-to-be.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result-expect-to-be.mjs","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"sourcesContent":["import { 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 * Unwraps a `Result`, returning the success value or throwing an error with\n * the provided message.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok('data');\n *\n * assert.isTrue(Result.expectToBe(okValue, 'should have value') === 'data');\n *\n * const expectResult = Result.expectToBe('missing result');\n *\n * const throwTest = (): void => {\n *   expectResult(Result.err('boom'));\n * };\n *\n * assert.throws(throwTest, /missing result/u);\n *\n * assert.isTrue(expectResult(Result.ok('value')) === 'value');\n * ```\n *\n * @template R The `UnknownResult` type to unwrap.\n * @param result The `Result` to unwrap.\n * @param message The error message to throw if the `Result` is `Result.Err`.\n * @returns The success value if `Result.Ok`.\n * @throws Error with the provided message if the `Result` is `Result.Err`.\n */\nexport function expectToBe<R extends UnknownResult>(\n  result: R,\n  message: string,\n): UnwrapOk<R>;\n\n// Curried version\nexport function expectToBe(\n  message: string,\n): <R extends UnknownResult>(result: R) => UnwrapOk<R>;\n\nexport function expectToBe<R extends UnknownResult>(\n  ...args: readonly [result: R, message: string] | readonly [message: string]\n): UnwrapOk<R> | ((result: R) => UnwrapOk<R>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, message] = args;\n\n      return expectToBeImpl(result, message);\n    }\n\n    case 1: {\n      // Curried version: first argument is message\n      const [message] = args;\n\n      return (result: R): UnwrapOk<R> => expectToBeImpl(result, message);\n    }\n  }\n}\n\nconst expectToBeImpl = <R extends UnknownResult>(\n  result: R,\n  message: string,\n): UnwrapOk<R> => {\n  if (isOk(result)) {\n    return unwrapOk(result);\n  }\n\n  throw new Error(message);\n};\n"],"names":[],"mappings":";;;AA2CO,SAAS,cACX,IAAA,EACyC;AAC5C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,OAAO,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,cAAA,CAAe,QAAQ,OAAO,CAAA;AAAA,IACvC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,OAAO,CAAA,GAAI,IAAA;AAElB,MAAA,OAAO,CAAC,MAAA,KAA2B,cAAA,CAAe,MAAA,EAAQ,OAAO,CAAA;AAAA,IACnE;AAAA;AAEJ;AAEA,MAAM,cAAA,GAAiB,CACrB,MAAA,EACA,OAAA,KACgB;AAChB,EAAA,IAAI,IAAA,CAAK,MAAM,CAAA,EAAG;AAChB,IAAA,OAAO,SAAS,MAAM,CAAA;AAAA,EACxB;AAEA,EAAA,MAAM,IAAI,MAAM,OAAO,CAAA;AACzB,CAAA;;;;"}
+{"version":3,"file":"result-expect-to-be.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAyClD,MAAM,UAAU,UAAU,CACxB,GAAG,IAAwE;IAE3E,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;YAE/B,OAAO,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACzC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,6CAA6C;YAC7C,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;YAEvB,OAAO,CAAC,MAAS,EAAe,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,OAAe,EACF,EAAE;IACf,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACjB,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC3B,CAAC,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"result-flat-map.mjs","sources":["../../../../src/functional/result/impl/result-flat-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 { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Applies a function that returns a `Result` to the success value of a\n * `Result`. If the input is `Err`, returns the original `Err`. This is the\n * monadic bind operation for `Result`.\n *\n * @example\n *\n * ```ts\n * const parseNumber = (input: string): Result<number, string> => {\n *   const num = Num.safeParseInt(input);\n *\n *   return Result.mapErr(num, () => 'not a number');\n * };\n *\n * const parsed = Result.flatMap(Result.ok('42'), parseNumber);\n *\n * const failure = Result.flatMap(Result.ok('abc'), parseNumber);\n *\n * const passthrough = Result.flatMap(Result.err('fail'), parseNumber);\n *\n * assert.deepStrictEqual(parsed, Result.ok(42));\n *\n * assert.deepStrictEqual(failure, Result.err('not a number'));\n *\n * assert.deepStrictEqual(passthrough, Result.err('fail'));\n *\n * const parseThenDouble = Result.flatMap((input: string) =>\n *   Result.map(parseNumber(input), (value) => value * 2),\n * );\n *\n * assert.deepStrictEqual(parseThenDouble(Result.ok('10')), Result.ok(20));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The success type of the `Result` returned by the function.\n * @template E2 The error type of the `Result` returned by the function.\n * @param result The `Result` to flat map.\n * @param flatMapFn The function to apply that returns a `Result`.\n * @returns The result of applying the function, or the original `Err`.\n */\nexport function flatMap<R extends UnknownResult, S2, E2>(\n  result: R,\n  flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>,\n): Result<S2, E2 | UnwrapErr<R>>;\n\n// Curried version\nexport function flatMap<S, S2, E2>(\n  flatMapFn: (value: S) => Result<S2, E2>,\n): <E>(result: Result<S, E>) => Result<S2, E | E2>;\n\nexport function flatMap<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [result: R, flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>]\n    | readonly [flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>]\n):\n  | Result<S2, E2 | UnwrapErr<R>>\n  | ((result: R) => Result<S2, UnwrapErr<R> | E2>) {\n  switch (args.length) {\n    case 2: {\n      // Direct version: first argument is result\n      const [result, flatMapFn] = args;\n\n      return flatMapImpl(result, flatMapFn);\n    }\n\n    case 1: {\n      // Curried version\n      const [flatMapFn] = args;\n\n      return (result: R) => flatMapImpl(result, flatMapFn);\n    }\n  }\n}\n\nconst flatMapImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>,\n): Result<S2, E2 | 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      flatMapFn(result.value as UnwrapOk<R>);\n"],"names":[],"mappings":";;AAuDO,SAAS,WACX,IAAA,EAK8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,SAAS,CAAA,GAAI,IAAA;AAE5B,MAAA,OAAO,WAAA,CAAY,QAAQ,SAAS,CAAA;AAAA,IACtC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,MAAA,KAAc,WAAA,CAAY,MAAA,EAAQ,SAAS,CAAA;AAAA,IACrD;AAAA;AAEJ;AAEA,MAAM,WAAA,GAAc,CAClB,MAAA,EACA,SAAA,KAEA,MAAM,MAAM,CAAA;AAAA;AAAA,EAEP;AAAA;AAAA;AAAA,EAED,SAAA,CAAU,OAAO,KAAoB;AAAA,CAAA;;;;"}
+{"version":3,"file":"result-flat-map.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-flat-map.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAqD5C,MAAM,UAAU,OAAO,CACrB,GAAG,IAE6D;IAIhE,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAC;YAEjC,OAAO,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QACxC,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;YAEzB,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,WAAW,GAAG,CAClB,MAAS,EACT,SAAiD,EAClB,EAAE,CACjC,KAAK,CAAC,MAAM,CAAC;IACX,CAAC,CAAC,oEAAoE;QACnE,MAA4B;IAC/B,CAAC,CAAC,oEAAoE;QACpE,SAAS,CAAC,MAAM,CAAC,KAAoB,CAAC,CAAC"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"result-fold.mjs","sources":["../../../../src/functional/result/impl/result-fold.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 { type UnwrapErr, type UnwrapOk } from './types.mjs';\n\n/**\n * Applies one of two functions depending on whether the `Result` is `Ok` or\n * `Err`.\n *\n * @example\n *\n * ```ts\n * const okValue = Result.ok(2);\n *\n * const errValue = Result.err('bad');\n *\n * const foldedOk = Result.fold(\n *   okValue,\n *   (value) => value * 2,\n *   (error) => error,\n * );\n *\n * const foldedErr = Result.fold(\n *   errValue,\n *   (value: number) => value * 2,\n *   (error) => error.toUpperCase(),\n * );\n *\n * assert.deepStrictEqual(foldedOk, Result.ok(4));\n *\n * assert.deepStrictEqual(foldedErr, Result.err('BAD'));\n *\n * const foldNumbers = Result.fold(\n *   (value: number) => value * 3,\n *   (error: string) => error.length,\n * );\n *\n * assert.deepStrictEqual(foldNumbers(Result.ok(3)), Result.ok(9));\n *\n * assert.deepStrictEqual(foldNumbers(Result.err('oops')), Result.err(4));\n * ```\n *\n * @template R The input `UnknownResult` type.\n * @template S2 The type of the success value returned by `mapFn`.\n * @template E2 The type of the error value returned by `mapErrFn`.\n * @param result The `Result` to fold.\n * @param mapFn The function to apply if `result` is `Ok`.\n * @param mapErrFn The function to apply if `result` is `Err`.\n * @returns A new `Result<S2, E2>` based on the applied function.\n */\nexport function fold<R extends UnknownResult, S2, E2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n  mapErrFn: (error: UnwrapErr<R>) => E2,\n): Result<S2, E2>;\n\n// Curried version\nexport function fold<S, E, S2, E2>(\n  mapFn: (value: S) => S2,\n  mapErrFn: (error: E) => E2,\n): (result: Result<S, E>) => Result<S2, E2>;\n\nexport function fold<R extends UnknownResult, S2, E2>(\n  ...args:\n    | readonly [\n        result: R,\n        mapFn: (value: UnwrapOk<R>) => S2,\n        mapErrFn: (error: UnwrapErr<R>) => E2,\n      ]\n    | readonly [\n        mapFn: (value: UnwrapOk<R>) => S2,\n        mapErrFn: (error: UnwrapErr<R>) => E2,\n      ]\n): Result<S2, E2> | ((result: R) => Result<S2, E2>) {\n  switch (args.length) {\n    case 3: {\n      // Direct version: first argument is result\n      const [result, mapFn, mapErrFn] = args;\n\n      return foldImpl(result, mapFn, mapErrFn);\n    }\n\n    case 2: {\n      // Curried version\n      const [mapFn, mapErrFn] = args;\n\n      return (result: R) => foldImpl(result, mapFn, mapErrFn);\n    }\n  }\n}\n\nconst foldImpl = <R extends UnknownResult, S2, E2>(\n  result: R,\n  mapFn: (value: UnwrapOk<R>) => S2,\n  mapErrFn: (error: UnwrapErr<R>) => E2,\n): Result<S2, E2> =>\n  isOk(result)\n    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      ok(mapFn(result.value as UnwrapOk<R>))\n    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      err(mapErrFn(result.value as UnwrapErr<R>));\n"],"names":[],"mappings":";;;;AA+DO,SAAS,QACX,IAAA,EAU+C;AAClD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,MAAA,EAAQ,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAElC,MAAA,OAAO,QAAA,CAAS,MAAA,EAAQ,KAAA,EAAO,QAAQ,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,CAAC,MAAA,KAAc,QAAA,CAAS,MAAA,EAAQ,OAAO,QAAQ,CAAA;AAAA,IACxD;AAAA;AAEJ;AAEA,MAAM,WAAW,CACf,MAAA,EACA,KAAA,EACA,QAAA,KAEA,KAAK,MAAM,CAAA;AAAA;AAAA,EAEP,EAAA,CAAG,KAAA,CAAM,MAAA,CAAO,KAAoB,CAAC;AAAA;AAAA;AAAA,EAErC,GAAA,CAAI,QAAA,CAAS,MAAA,CAAO,KAAqB,CAAC;AAAA,CAAA;;;;"}
+{"version":3,"file":"result-fold.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-fold.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;AA4DrC,MAAM,UAAU,IAAI,CAClB,GAAG,IASE;IAEL,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,2CAA2C;YAC3C,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;YAEvC,OAAO,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC3C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,kBAAkB;YAClB,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;YAE/B,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,QAAQ,GAAG,CACf,MAAS,EACT,KAAiC,EACjC,QAAqC,EACrB,EAAE,CAClB,IAAI,CAAC,MAAM,CAAC;IACV,CAAC,CAAC,oEAAoE;QACpE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAoB,CAAC,CAAC;IACxC,CAAC,CAAC,oEAAoE;QACpE,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC,CAAC"}

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

@@ -1,24 +1,21 @@
-import { isSome } from '../../optional/impl/optional-is-some.mjs';
-import { unwrap } from '../../optional/impl/optional-unwrap.mjs';
+import { Optional } from '../../optional/index.mjs';
 import { err } from './result-err.mjs';
 import { ok } from './result-ok.mjs';
-
-function fromOptional(...args) {
-  switch (args.length) {
-    case 2: {
-      const [optional, error] = args;
-      return fromOptionalImpl(optional, error);
+export function fromOptional(...args) {
+    switch (args.length) {
+        case 2: {
+            const [optional, error] = args;
+            return fromOptionalImpl(optional, error);
+        }
+        case 1: {
+            // Curried version: the only argument is the error value
+            const [error] = args;
+            return (optional) => fromOptionalImpl(optional, error);
+        }
     }
-    case 1: {
-      const [error] = args;
-      return (optional) => fromOptionalImpl(optional, error);
-    }
-  }
 }
-const fromOptionalImpl = (optional, error) => isSome(optional) ? (
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  ok(unwrap(optional))
-) : err(error);
-
-export { fromOptional };
-//# sourceMappingURL=result-from-optional.mjs.map
+const fromOptionalImpl = (optional, error) => Optional.isSome(optional)
+    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        ok(Optional.unwrap(optional))
+    : err(error);
+//# sourceMappingURL=result-from-optional.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-optional.mjs","sources":["../../../../src/functional/result/impl/result-from-optional.mts"],"sourcesContent":["import { Optional, type UnknownOptional } from '../../optional/index.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * Converts an {@link Optional} to a `Result` (the inverse of\n * {@link Result.toOptional}, and the equivalent of Rust's `Option::ok_or`).\n *\n * If the {@link Optional} is `Some`, returns `Ok` with the contained value.\n * If it is `None`, returns `Err` with the provided error value.\n *\n * @example\n *\n * ```ts\n * assert.deepStrictEqual(\n *   Result.fromOptional(Optional.some(42), 'missing'),\n *   Result.ok(42),\n * );\n *\n * assert.deepStrictEqual(\n *   Result.fromOptional(Optional.none, 'missing'),\n *   Result.err('missing'),\n * );\n *\n * const withMissingError = Result.fromOptional('missing');\n *\n * assert.deepStrictEqual(withMissingError(Optional.some(1)), Result.ok(1));\n *\n * assert.deepStrictEqual(\n *   withMissingError(Optional.none),\n *   Result.err('missing'),\n * );\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template E The type of the error value used for the `None` case.\n * @param optional The `Optional` to convert.\n * @param error The error value to use if the `Optional` is `None`.\n * @returns `Ok` with the contained value, or `Err` with `error`.\n */\nexport function fromOptional<O extends UnknownOptional, const E>(\n  optional: O,\n  error: E,\n): Result<Optional.Unwrap<O>, E>;\n\n// Curried version\nexport function fromOptional<const E>(\n  error: E,\n): <O extends UnknownOptional>(optional: O) => Result<Optional.Unwrap<O>, E>;\n\nexport function fromOptional<O extends UnknownOptional, const E>(\n  ...args: readonly [optional: O, error: E] | readonly [error: E]\n):\n  | Result<Optional.Unwrap<O>, E>\n  | ((optional: O) => Result<Optional.Unwrap<O>, E>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, error] = args;\n\n      return fromOptionalImpl(optional, error);\n    }\n\n    case 1: {\n      // Curried version: the only argument is the error value\n      const [error] = args;\n\n      return (optional: O) => fromOptionalImpl(optional, error);\n    }\n  }\n}\n\nconst fromOptionalImpl = <O extends UnknownOptional, E>(\n  optional: O,\n  error: E,\n): Result<Optional.Unwrap<O>, E> =>\n  Optional.isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      ok(Optional.unwrap(optional)!)\n    : err(error);\n"],"names":["Optional.isSome","Optional.unwrap"],"mappings":";;;;;AAmDO,SAAS,gBACX,IAAA,EAGgD;AACnD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,gBAAA,CAAiB,UAAU,KAAK,CAAA;AAAA,IACzC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,gBAAA,CAAiB,QAAA,EAAU,KAAK,CAAA;AAAA,IAC1D;AAAA;AAEJ;AAEA,MAAM,mBAAmB,CACvB,QAAA,EACA,KAAA,KAEAA,OAAgB,QAAQ,CAAA;AAAA;AAAA,EAEpB,EAAA,CAAGC,MAAS,CAAO,QAAQ,CAAE;AAAA,IAC7B,IAAI,KAAK,CAAA;;;;"}
+{"version":3,"file":"result-from-optional.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-optional.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAwB,MAAM,0BAA0B,CAAC;AAE1E,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAgDrC,MAAM,UAAU,YAAY,CAC1B,GAAG,IAA4D;IAI/D,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC,EAAE,CAAC;YACP,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;YAE/B,OAAO,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC3C,CAAC;QAED,KAAK,CAAC,EAAE,CAAC;YACP,wDAAwD;YACxD,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;YAErB,OAAO,CAAC,QAAW,EAAE,EAAE,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,gBAAgB,GAAG,CACvB,QAAW,EACX,KAAQ,EACuB,EAAE,CACjC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC;IACvB,CAAC,CAAC,oEAAoE;QACpE,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAE,CAAC;IAChC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC"}

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

@@ -1,10 +1,39 @@
 import { err } from './result-err.mjs';
 import { ok } from './result-ok.mjs';
-
-const fromPromise = (promise) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  promise.then((v) => ok(v)).catch(err)
-);
-
-export { fromPromise };
-//# sourceMappingURL=result-from-promise.mjs.map
+/**
+ * Converts a Promise into a Promise that resolves to a `Result`. If the input
+ * Promise resolves, the `Result` will be `Ok` with the resolved value. If the
+ * input Promise rejects, the `Result` will be `Err` with the rejection
+ * reason.
+ *
+ * The error channel is `unknown`, since the rejection reason is carried
+ * through untouched. For a concrete error type, use `AsyncResult.fromPromise`
+ * with a `mapError` function; called without one it behaves exactly as this
+ * function does.
+ *
+ * @example
+ *
+ * ```ts
+ * const successPromise = Result.fromPromise(Promise.resolve('ok'));
+ *
+ * const failurePromise = Result.fromPromise(
+ *   Promise.reject(new Error('fail')),
+ * );
+ *
+ * const resolved = await successPromise;
+ *
+ * const rejected = await failurePromise;
+ *
+ * assert.deepStrictEqual(resolved, Result.ok('ok'));
+ *
+ * assert.isTrue(Result.isErr(rejected));
+ * ```
+ *
+ * @template P The type of the input Promise.
+ * @param promise The Promise to convert.
+ * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.
+ */
+export const fromPromise = (promise) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+promise.then((v) => ok(v)).catch(err);
+//# sourceMappingURL=result-from-promise.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":["import { type Ok } from '../../../types.mjs';\nimport { type Result } from '../result.mjs';\nimport { err } from './result-err.mjs';\nimport { ok } from './result-ok.mjs';\n\n/**\n * @template P The Promise type.\n * @internal\n * Utility type to extract the resolved value type from a Promise.\n */\ntype UnwrapPromise<P extends Promise<unknown>> =\n  P extends Promise<infer V> ? V : never;\n\n/**\n * Converts a Promise into a Promise that resolves to a `Result`. If the input\n * Promise resolves, the `Result` will be `Ok` with the resolved value. If the\n * input Promise rejects, the `Result` will be `Err` with the rejection\n * reason.\n *\n * The error channel is `unknown`, since the rejection reason is carried\n * through untouched. For a concrete error type, use `AsyncResult.fromPromise`\n * with a `mapError` function; called without one it behaves exactly as this\n * function does.\n *\n * @example\n *\n * ```ts\n * const successPromise = Result.fromPromise(Promise.resolve('ok'));\n *\n * const failurePromise = Result.fromPromise(\n *   Promise.reject(new Error('fail')),\n * );\n *\n * const resolved = await successPromise;\n *\n * const rejected = await failurePromise;\n *\n * assert.deepStrictEqual(resolved, Result.ok('ok'));\n *\n * assert.isTrue(Result.isErr(rejected));\n * ```\n *\n * @template P The type of the input Promise.\n * @param promise The Promise to convert.\n * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.\n */\nexport const fromPromise = <P extends Promise<unknown>>(\n  promise: P,\n): Promise<Result<UnwrapPromise<P>, unknown>> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  promise.then((v) => ok(v) as Ok<UnwrapPromise<P>>).catch(err);\n"],"names":[],"mappings":";;;AA8CO,MAAM,cAAc,CACzB,OAAA;AAAA;AAAA,EAGA,OAAA,CAAQ,KAAK,CAAC,CAAA,KAAM,GAAG,CAAC,CAAyB,CAAA,CAAE,KAAA,CAAM,GAAG;AAAA;;;;"}
+{"version":3,"file":"result-from-promise.mjs","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAC;AAUrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,OAAU,EACkC,EAAE;AAC9C,oEAAoE;AACpE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAyB,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}