ts-data-forge 14.1.0 → 14.2.0

package/dist/functional/optional/impl/optional-map.d.mts

@@ -30,5 +30,5 @@ import { type Unwrap } from './types.mjs';
  *   `None` if the input was `None`.
  */
 export declare function map<O extends UnknownOptional, S2>(optional: O, mapFn: (value: Unwrap<O>) => S2): Optional<S2>;
-export declare function map<S, S2>(mapFn: (value: S) => S2): (optional: Optional<S>) => Optional<S2>;
+export declare function map<S, S2>(mapFn: (value: S) => S2): <O extends UnknownOptional>(optional: Unwrap<O> extends S ? O : never) => Optional<S2>;
 //# sourceMappingURL=optional-map.d.mts.map

package/dist/functional/optional/impl/optional-map.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"optional-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAKtE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,eAAe,EAAE,EAAE,EAC/C,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,GAC9B,QAAQ,CAAC,EAAE,CAAC,CAAC;AAGhB,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC,CAAC"}
+{"version":3,"file":"optional-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAKtE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,eAAe,EAAE,EAAE,EAC/C,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,GAC9B,QAAQ,CAAC,EAAE,CAAC,CAAC;AAgBhB,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,SAAS,eAAe,EAC3B,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,KACtC,QAAQ,CAAC,EAAE,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"optional-map.mjs","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Maps an {@link Optional}<S> to {@link Optional}<S2> by applying a function to\n * a contained value. If the {@link Optional} is {@link None}, it\n * returns {@link Optional.none}. Otherwise, it applies the `mapFn` to the\n * value in `Some` and returns a new `Some` with the result.\n *\n * @example\n *\n * ```ts\n * const numberOptional = Optional.some(21);\n *\n * const mapped = Optional.map(numberOptional, (value) => value * 2);\n *\n * assert.deepStrictEqual(mapped, Optional.some(42));\n *\n * const mapToLength = Optional.map((text: string) => text.length);\n *\n * assert.deepStrictEqual(mapToLength(Optional.some('abc')), Optional.some(3));\n *\n * assert.deepStrictEqual(mapToLength(Optional.none), Optional.none);\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template S2 The type of the value returned by the mapping function.\n * @param optional The `Optional` to map.\n * @param mapFn The function to apply to the value if it exists.\n * @returns A new `Optional<S2>` resulting from the mapping, or\n *   `None` if the input was `None`.\n */\nexport function map<O extends UnknownOptional, S2>(\n  optional: O,\n  mapFn: (value: Unwrap<O>) => S2,\n): Optional<S2>;\n\n// Curried version\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): (optional: Optional<S>) => Optional<S2>;\n\nexport function map<O extends UnknownOptional, S2>(\n  ...args:\n    | readonly [optional: O, mapFn: (value: Unwrap<O>) => S2]\n    | readonly [mapFn: (value: Unwrap<O>) => S2]\n): Optional<S2> | ((optional: O) => Optional<S2>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, mapFn] = args;\n\n      return mapImpl(optional, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (optional: O) => mapImpl(optional, mapFn);\n    }\n  }\n}\n\nconst mapImpl = <O extends UnknownOptional, S2>(\n  optional: O,\n  mapFn: (value: Unwrap<O>) => S2,\n): Optional<S2> =>\n  isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      some(mapFn(unwrap(optional)!))\n    : none;\n"],"names":[],"mappings":";;;;;AA8CO,SAAS,OACX,IAAA,EAG6C;AAChD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,OAAA,CAAQ,UAAU,KAAK,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,OAAA,CAAQ,QAAA,EAAU,KAAK,CAAA;AAAA,IACjD;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,CACd,QAAA,EACA,KAAA,KAEA,OAAO,QAAQ,CAAA;AAAA;AAAA,EAEX,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,QAAQ,CAAE,CAAC;AAAA,IAC7B,IAAA;;;;"}
+{"version":3,"file":"optional-map.mjs","sources":["../../../../src/functional/optional/impl/optional-map.mts"],"sourcesContent":["import { type Optional, type UnknownOptional } from '../optional.mjs';\nimport { isSome } from './optional-is-some.mjs';\nimport { none } from './optional-none.mjs';\nimport { some } from './optional-some.mjs';\nimport { unwrap } from './optional-unwrap.mjs';\nimport { type Unwrap } from './types.mjs';\n\n/**\n * Maps an {@link Optional}<S> to {@link Optional}<S2> by applying a function to\n * a contained value. If the {@link Optional} is {@link None}, it\n * returns {@link Optional.none}. Otherwise, it applies the `mapFn` to the\n * value in `Some` and returns a new `Some` with the result.\n *\n * @example\n *\n * ```ts\n * const numberOptional = Optional.some(21);\n *\n * const mapped = Optional.map(numberOptional, (value) => value * 2);\n *\n * assert.deepStrictEqual(mapped, Optional.some(42));\n *\n * const mapToLength = Optional.map((text: string) => text.length);\n *\n * assert.deepStrictEqual(mapToLength(Optional.some('abc')), Optional.some(3));\n *\n * assert.deepStrictEqual(mapToLength(Optional.none), Optional.none);\n * ```\n *\n * @template O The input `UnknownOptional` type.\n * @template S2 The type of the value returned by the mapping function.\n * @param optional The `Optional` to map.\n * @param mapFn The function to apply to the value if it exists.\n * @returns A new `Optional<S2>` resulting from the mapping, or\n *   `None` if the input was `None`.\n */\nexport function map<O extends UnknownOptional, S2>(\n  optional: O,\n  mapFn: (value: Unwrap<O>) => S2,\n): Optional<S2>;\n\n// Curried version\n//\n// The returned function is generic over the *whole* optional, mirroring the\n// direct overload above, rather than fixing its parameter to `Optional<S>`.\n// Fixing it makes the curried form unusable from a caller that is itself\n// generic over the optional: with `S` bound to `Unwrap<O>` at currying time\n// the parameter becomes `Optional<Unwrap<O>>`, and TypeScript cannot show a\n// bare `O extends UnknownOptional` is assignable to that — although every\n// concrete instantiation of `O` is.\n//\n// The conditional is what keeps the check: `O` is inferred from the argument\n// and its value type still has to satisfy `S`, so mapping a `(s: string) =>\n// …` over an `Optional<number>` stays an error. The cost is the message it\n// produces — \"not assignable to `never`\" rather than naming the two optionals.\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): <O extends UnknownOptional>(\n  optional: Unwrap<O> extends S ? O : never,\n) => Optional<S2>;\n\nexport function map<O extends UnknownOptional, S2>(\n  ...args:\n    | readonly [optional: O, mapFn: (value: Unwrap<O>) => S2]\n    | readonly [mapFn: (value: Unwrap<O>) => S2]\n): Optional<S2> | ((optional: O) => Optional<S2>) {\n  switch (args.length) {\n    case 2: {\n      const [optional, mapFn] = args;\n\n      return mapImpl(optional, mapFn);\n    }\n\n    case 1: {\n      // Curried version: first argument is mapping function\n      const [mapFn] = args;\n\n      return (optional: O) => mapImpl(optional, mapFn);\n    }\n  }\n}\n\nconst mapImpl = <O extends UnknownOptional, S2>(\n  optional: O,\n  mapFn: (value: Unwrap<O>) => S2,\n): Optional<S2> =>\n  isSome(optional)\n    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      some(mapFn(unwrap(optional)!))\n    : none;\n"],"names":[],"mappings":";;;;;AA6DO,SAAS,OACX,IAAA,EAG6C;AAChD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,QAAA,EAAU,KAAK,CAAA,GAAI,IAAA;AAE1B,MAAA,OAAO,OAAA,CAAQ,UAAU,KAAK,CAAA;AAAA,IAChC;AAAA,IAEA,KAAK,CAAA,EAAG;AAEN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,QAAA,KAAgB,OAAA,CAAQ,QAAA,EAAU,KAAK,CAAA;AAAA,IACjD;AAAA;AAEJ;AAEA,MAAM,OAAA,GAAU,CACd,QAAA,EACA,KAAA,KAEA,OAAO,QAAQ,CAAA;AAAA;AAAA,EAEX,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,QAAQ,CAAE,CAAC;AAAA,IAC7B,IAAA;;;;"}

package/dist/functional/result/impl/result-map-err.d.mts

@@ -35,5 +35,5 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  * @returns A new `Result<UnwrapOk<R>, E2>`.
  */
 export declare function mapErr<R extends UnknownResult, E2>(result: R, mapFn: (error: UnwrapErr<R>) => E2): Result<UnwrapOk<R>, E2>;
-export declare function mapErr<E, E2>(mapFn: (error: E) => E2): <S>(result: Result<S, E>) => Result<S, E2>;
+export declare function mapErr<E, E2>(mapFn: (error: E) => E2): <R extends UnknownResult>(result: UnwrapErr<R> extends E ? R : never) => Result<UnwrapOk<R>, E2>;
 //# sourceMappingURL=result-map-err.d.mts.map

package/dist/functional/result/impl/result-map-err.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-map-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAChD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,GACjC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAG3B,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC"}
+{"version":3,"file":"result-map-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAChD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,GACjC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAgB3B,wBAAgB,MAAM,CAAC,CAAC,EAAE,EAAE,EAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,SAAS,aAAa,EACzB,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,KACvC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC"}

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\nexport function mapErr<E, E2>(\n  mapFn: (error: E) => E2,\n): <S>(result: Result<S, E>) => Result<S, 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":";;;AAkDO,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","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;;;;"}

package/dist/functional/result/impl/result-map.d.mts

@@ -35,5 +35,5 @@ import { type UnwrapErr, type UnwrapOk } from './types.mjs';
  * @returns A new `Result<S2, UnwrapErr<R>>`.
  */
 export declare function map<R extends UnknownResult, S2>(result: R, mapFn: (value: UnwrapOk<R>) => S2): Result<S2, UnwrapErr<R>>;
-export declare function map<S, S2>(mapFn: (value: S) => S2): <E>(result: Result<S, E>) => Result<S2, E>;
+export declare function map<S, S2>(mapFn: (value: S) => S2): <R extends UnknownResult>(result: UnwrapOk<R> extends S ? R : never) => Result<S2, UnwrapErr<R>>;
 //# sourceMappingURL=result-map.d.mts.map

package/dist/functional/result/impl/result-map.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAC7C,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,GAChC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAG5B,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"result-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAC7C,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,GAChC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAgB5B,wBAAgB,GAAG,CAAC,CAAC,EAAE,EAAE,EACvB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACtB,CAAC,CAAC,SAAS,aAAa,EACzB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,KACtC,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC"}

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\nexport function map<S, S2>(\n  mapFn: (value: S) => S2,\n): <E>(result: Result<S, E>) => Result<S2, E>;\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":";;;AAkDO,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","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;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.1.0",
+  "version": "14.2.0",
   "private": false,
   "keywords": [
     "typescript",

package/src/functional/optional/impl/optional-map.mts

@@ -40,9 +40,24 @@ export function map<O extends UnknownOptional, S2>(
 ): Optional<S2>;
 
 // Curried version
+//
+// The returned function is generic over the *whole* optional, mirroring the
+// direct overload above, rather than fixing its parameter to `Optional<S>`.
+// Fixing it makes the curried form unusable from a caller that is itself
+// generic over the optional: with `S` bound to `Unwrap<O>` at currying time
+// the parameter becomes `Optional<Unwrap<O>>`, and TypeScript cannot show a
+// bare `O extends UnknownOptional` is assignable to that — although every
+// concrete instantiation of `O` is.
+//
+// The conditional is what keeps the check: `O` is inferred from the argument
+// and its value type still has to satisfy `S`, so mapping a `(s: string) =>
+// …` over an `Optional<number>` stays an error. The cost is the message it
+// produces — "not assignable to `never`" rather than naming the two optionals.
 export function map<S, S2>(
   mapFn: (value: S) => S2,
-): (optional: Optional<S>) => Optional<S2>;
+): <O extends UnknownOptional>(
+  optional: Unwrap<O> extends S ? O : never,
+) => Optional<S2>;
 
 export function map<O extends UnknownOptional, S2>(
   ...args:

package/src/functional/optional.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { Num } from '../number/index.mjs';
 import { type None, type Some } from '../types.mjs';
-import { Optional } from './optional/index.mjs';
+import { Optional, type UnknownOptional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
 import { Result } from './result/index.mjs';
 
@@ -144,6 +144,53 @@ describe('Optional test', () => {
       }
     });
 
+    test('curried form is usable from a caller generic over the optional', () => {
+      // The motivating case: with the curried parameter fixed to
+      // `Optional<S>`, `S` binds to `Optional.Unwrap<O>` here and a bare
+      // `O extends UnknownOptional` is not assignable to
+      // `Optional<Optional.Unwrap<O>>`, so this only compiles because the
+      // returned function is generic over the whole optional.
+      const liftMap =
+        <O extends UnknownOptional, B>(mapFn: (x: Optional.Unwrap<O>) => B) =>
+        (optional: O): Optional<B> =>
+          Optional.map(mapFn)(optional);
+
+      const lengthOf = liftMap<Optional<string>, number>((s) => s.length);
+
+      const mapped = lengthOf(Optional.some('abc'));
+
+      expectType<typeof mapped, Optional<number>>('=');
+
+      assert.deepStrictEqual(mapped, Optional.some(3));
+
+      assert.deepStrictEqual(lengthOf(Optional.none), Optional.none);
+    });
+
+    test('curried form still infers the result precisely', () => {
+      const mapToLength = Optional.map((text: string) => text.length);
+
+      const mapped = mapToLength(Optional.some('abc'));
+
+      expectType<typeof mapped, Optional<number>>('=');
+
+      assert.deepStrictEqual(mapped, Optional.some(3));
+
+      const empty = mapToLength(Optional.none);
+
+      expectType<typeof empty, Optional<number>>('=');
+
+      assert.deepStrictEqual(empty, Optional.none);
+    });
+
+    test('curried form still rejects a mismatched value type', () => {
+      const mapToLength = Optional.map((text: string) => text.length);
+
+      // @ts-expect-error an Optional<number> is not an Optional<string>
+      const rejected = (): unknown => mapToLength(Optional.some(42));
+
+      expect(rejected).toBeTypeOf('function');
+    });
+
     test('should preserve types correctly', () => {
       const some = Optional.some(42);
 

package/src/functional/result/impl/result-map-err.mts

@@ -44,9 +44,24 @@ export function mapErr<R extends UnknownResult, E2>(
 ): Result<UnwrapOk<R>, E2>;
 
 // Curried version
+//
+// The returned function is generic over the *whole* result, mirroring the
+// direct overload above, rather than fixing its parameter to `Result<S, E>`.
+// Fixing it makes the curried form unusable from a caller that is itself
+// generic over the result: with `E` bound to `UnwrapErr<R>` at currying time the
+// parameter becomes `Result<...>` in terms of `R`, and TypeScript cannot show
+// a bare `R extends UnknownResult` is assignable to that — although every
+// concrete instantiation of `R` is.
+//
+// The conditional is what keeps the check: `R` is inferred from the argument
+// and its error type still has to satisfy `E`, so the mismatched case stays an
+// error. The cost is the message it produces — "not assignable to `never`"
+// rather than naming the two results.
 export function mapErr<E, E2>(
   mapFn: (error: E) => E2,
-): <S>(result: Result<S, E>) => Result<S, E2>;
+): <R extends UnknownResult>(
+  result: UnwrapErr<R> extends E ? R : never,
+) => Result<UnwrapOk<R>, E2>;
 
 export function mapErr<R extends UnknownResult, E2>(
   ...args:

package/src/functional/result/impl/result-map.mts

@@ -44,9 +44,24 @@ export function map<R extends UnknownResult, S2>(
 ): Result<S2, UnwrapErr<R>>;
 
 // Curried version
+//
+// The returned function is generic over the *whole* result, mirroring the
+// direct overload above, rather than fixing its parameter to `Result<S, E>`.
+// Fixing it makes the curried form unusable from a caller that is itself
+// generic over the result: with `S` bound to `UnwrapOk<R>` at currying time the
+// parameter becomes `Result<...>` in terms of `R`, and TypeScript cannot show
+// a bare `R extends UnknownResult` is assignable to that — although every
+// concrete instantiation of `R` is.
+//
+// The conditional is what keeps the check: `R` is inferred from the argument
+// and its success type still has to satisfy `S`, so the mismatched case stays an
+// error. The cost is the message it produces — "not assignable to `never`"
+// rather than naming the two results.
 export function map<S, S2>(
   mapFn: (value: S) => S2,
-): <E>(result: Result<S, E>) => Result<S2, E>;
+): <R extends UnknownResult>(
+  result: UnwrapOk<R> extends S ? R : never,
+) => Result<S2, UnwrapErr<R>>;
 
 export function map<R extends UnknownResult, S2>(
   ...args:

package/src/functional/result.test.mts

@@ -3,7 +3,7 @@ import { Num } from '../number/index.mjs';
 import { type Err, type Ok } from '../types.mjs';
 import { Optional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
-import { Result } from './result/index.mjs';
+import { Result, type UnknownResult } from './result/index.mjs';
 
 describe('Result test', () => {
   describe('ok', () => {
@@ -174,6 +174,49 @@ describe('Result test', () => {
 
       expect(result.value).toBe('10');
     });
+
+    test('curried form is usable from a caller generic over the result', () => {
+      // The motivating case: with the curried parameter fixed to
+      // `Result<S, E>`, `S` binds to `Result.UnwrapOk<R>` here and a bare
+      // `R extends UnknownResult` is not assignable to that, so this only
+      // compiles because the returned function is generic over the whole
+      // result.
+      const liftMap =
+        <R extends UnknownResult, S2>(mapFn: (x: Result.UnwrapOk<R>) => S2) =>
+        (result: R): Result<S2, Result.UnwrapErr<R>> =>
+          Result.map(mapFn)(result);
+
+      const lengthOf = liftMap<Result<string, 'boom'>, number>((s) => s.length);
+
+      const mapped = lengthOf(Result.ok('abc'));
+
+      expectType<typeof mapped, Result<number, 'boom'>>('=');
+
+      assert.deepStrictEqual(mapped, Result.ok(3));
+
+      assert.deepStrictEqual(lengthOf(Result.err('boom')), Result.err('boom'));
+    });
+
+    test('curried form keeps the error type and rejects a mismatch', () => {
+      const mapToLength = Result.map((text: string) => text.length);
+
+      const mapped = mapToLength(Result.ok('abc'));
+
+      expectType<typeof mapped, Result<number, never>>('=');
+
+      assert.deepStrictEqual(mapped, Result.ok(3));
+
+      const failed = mapToLength(Result.err('boom' as const));
+
+      expectType<typeof failed, Result<number, 'boom'>>('=');
+
+      assert.deepStrictEqual(failed, Result.err('boom'));
+
+      // @ts-expect-error a Result<number, …> is not a Result<string, …>
+      const rejected = (): unknown => mapToLength(Result.ok(42));
+
+      expect(rejected).toBeTypeOf('function');
+    });
   });
 
   describe('mapErr', () => {
@@ -234,6 +277,40 @@ describe('Result test', () => {
 
       expect(result.value).toBe('ERROR: FAILED');
     });
+
+    test('curried form is usable from a caller generic over the result', () => {
+      const liftMapErr =
+        <R extends UnknownResult, E2>(mapFn: (x: Result.UnwrapErr<R>) => E2) =>
+        (result: R): Result<Result.UnwrapOk<R>, E2> =>
+          Result.mapErr(mapFn)(result);
+
+      const shout = liftMapErr<Result<number, string>, string>((e) =>
+        e.toUpperCase(),
+      );
+
+      const mapped = shout(Result.err('failed'));
+
+      expectType<typeof mapped, Result<number, string>>('=');
+
+      assert.deepStrictEqual(mapped, Result.err('FAILED'));
+
+      assert.deepStrictEqual(shout(Result.ok(1)), Result.ok(1));
+    });
+
+    test('curried form keeps the ok type and rejects a mismatch', () => {
+      const shout = Result.mapErr((e: string) => e.toUpperCase());
+
+      const mapped = shout(Result.err('failed'));
+
+      expectType<typeof mapped, Result<never, string>>('=');
+
+      assert.deepStrictEqual(mapped, Result.err('FAILED'));
+
+      // @ts-expect-error a Result<…, number> is not a Result<…, string>
+      const rejected = (): unknown => shout(Result.err(42));
+
+      expect(rejected).toBeTypeOf('function');
+    });
   });
 
   describe('unwrapThrow', () => {