ts-data-forge 6.12.0 → 6.13.1

package/dist/functional/pipe.d.mts

@@ -1,4 +1,3 @@
-import { type MergeIntersection } from 'ts-type-forge';
 import { Optional, type UnknownOptional } from './optional/index.mjs';
 /**
  * Creates a new pipe object that allows for chaining operations on a value.
@@ -18,15 +17,8 @@ import { Optional, type UnknownOptional } from './optional/index.mjs';
  * @param a The initial value to wrap in a pipe.
  * @returns A pipe object with chaining methods appropriate for the value type.
  */
-export declare function pipe<const A extends UnknownOptional>(a: A): PipeWithMapOptional<A>;
-export declare function pipe<const A>(a: A): PipeBase<A>;
-type Pipe<A> = A extends UnknownOptional ? PipeWithMapOptional<A> : PipeBase<A>;
-/**
- * @template A The type of the current value in the pipe.
- * @internal
- * Base pipe interface providing core functionality.
- * All pipe types extend this interface.
- */
+export declare const pipe: <const A>(a: A) => Pipe<A>;
+export type Pipe<A> = PipeBase<A> & PipeMapNullable<A> & ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown);
 type PipeBase<A> = Readonly<{
     /** The current value being piped. */
     value: A;
@@ -48,6 +40,8 @@ type PipeBase<A> = Readonly<{
      * @returns A new pipe containing the transformed value.
      */
     map: <B>(fn: (a: A) => B) => Pipe<B>;
+}>;
+type PipeMapNullable<A> = Readonly<{
     /**
      * Maps the current value only if it's not null or undefined. If the current
      * value is null/undefined, the transformation is skipped and undefined is
@@ -75,13 +69,7 @@ type PipeBase<A> = Readonly<{
      */
     mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;
 }>;
-/**
- * @template A The Optional type currently in the pipe.
- * @internal
- * Pipe interface for Optional values, providing Optional-aware mapping.
- * Extends PipeBase with mapOptional functionality for monadic operations.
- */
-type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<PipeBase<A> & Readonly<{
+type PipeMapOptional<A extends UnknownOptional> = Readonly<{
     /**
      * Maps the value inside an Optional using Optional.map semantics. If the
      * Optional is None, the transformation is skipped and None is propagated.
@@ -109,6 +97,6 @@ type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<PipeBase
      * @returns A new pipe containing an Optional with the transformed value.
      */
     mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;
-}>>;
+}>;
 export {};
 //# sourceMappingURL=pipe.d.mts.map

package/dist/functional/pipe.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,eAAe,EAClD,CAAC,EAAE,CAAC,GACH,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE1B,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAkBjD,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,eAAe,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,eAAe,IAAI,iBAAiB,CACrE,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CACL,CAAC"}
+{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,CAAC,EAAG,GAAG,CAAC,KAAG,IAAI,CAAC,CAAC,CAYI,CAAC;AAmBjD,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAC/B,eAAe,CAAC,CAAC,CAAC,GAClB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;AAgCjE,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;CACtC,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,IAAI,QAAQ,CAAC;IACjC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH,KAAK,eAAe,CAAC,CAAC,SAAS,eAAe,IAAI,QAAQ,CAAC;IACzD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CAAC"}

package/dist/functional/pipe.mjs

@@ -1,22 +1,42 @@
 import { isOptional } from './optional/impl/optional-is-optional.mjs';
 import { map } from './optional/impl/optional-map.mjs';
 
-function pipe(a) {
-    if (isOptional(a)) {
-        return {
-            value: a,
-            map: (fn) => pipe(fn(a)),
+/**
+ * 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.
+ */
+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 ? undefined : fn(a)),
+    ...(isOptional(a)
+        ? {
             mapOptional: (fn) => pipe(map(a, fn)),
-        };
-    }
-    else {
-        return {
-            value: a,
-            map: (fn) => pipe(fn(a)),
-            mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
-        };
-    }
-}
+        }
+        : {}),
+});
+// NOTE: 以下では 'typing when used with generics' test で型エラーが出る。
+// 詳細は documents/reports/pipe-typing.md の 「mapNullable を条件付きで含めるのがうまくいかない理由」を参照。
+// export type Pipe<A> = PipeBase<A> &
+//   ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown) &
+//   ([undefined] extends [A] ? PipeMapNullable<A> : unknown) &
+//   ([null] extends [A] ? PipeMapNullable<A> : unknown);
 
 export { pipe };
 //# sourceMappingURL=pipe.mjs.map

package/dist/functional/pipe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AA2BM,SAAU,IAAI,CAAU,CAAI,EAAA;AAChC,IAAA,IAAIA,UAAmB,CAAC,CAAC,CAAC,EAAE;QAC1B,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACxB,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAACC,GAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;IACH;SAAO;QACL,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;IACH;AACF;;;;"}
+{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,IAAI,GAAG,CAAW,CAAI;AACjC;AACA,CAAC;AACC,IAAA,KAAK,EAAE,CAAC;AACR,IAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAExD,IAAA,IAAIA,UAAmB,CAAC,CAAC;AACvB,UAAE;AACE,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAACC,GAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC/C;UACD,EAAE,CAAC;AACR,CAAA;AAuBH;AACA;AACA;AACA;AACA;AACA;;;;"}

package/dist/number/num.d.mts

@@ -1,4 +1,4 @@
-import { type Decrement, type Increment, type Index, type Int, type Min, type NaNType, type NegativeIndex, type NonNegativeNumber, type NonZeroNumber, type PositiveNumber, type PositiveSafeIntWithSmallInt, type RelaxedExclude, type SmallInt, type SmallUint } from 'ts-type-forge';
+import { type Decrement, type FiniteNumber, type Increment, type Index, type Int, type Min, type NaNType, type NegativeIndex, type NonNegativeNumber, type NonZeroNumber, type PositiveNumber, type PositiveSafeIntWithSmallInt, type RelaxedExclude, type SmallInt, type SmallUint } from 'ts-type-forge';
 import { Result } from '../functional/index.mjs';
 import { type SmallPositiveInt } from '../types.mjs';
 /**
@@ -98,6 +98,70 @@ export declare namespace Num {
      *   wrapping an `Error` describing the invalid input.
      */
     export const safeParseInt: (s: string) => Result<Int, Error>;
+    /**
+     * Safely parses a finite floating-point number from a string, returning a
+     * {@link Result} that is `Ok<FiniteNumber>` for valid input and `Err<Error>`
+     * otherwise.
+     *
+     * This is a stricter alternative to both `parseFloat` and `Number`:
+     *
+     * - Unlike `parseFloat('12abc')` (which returns `12`), trailing non-numeric
+     *   characters make the whole input invalid and yield `Err`.
+     * - Unlike `Number('')` / `Number('   ')` (which return `0`), empty or
+     *   whitespace-only input yields `Err`.
+     * - Unlike `Number('Infinity')` (which returns `Infinity`), non-finite values
+     *   yield `Err`.
+     *
+     * The empty-string case is rejected by delegating to `parseFloat` (which
+     * returns `NaN` there) rather than hard-coding a check, while the trailing-
+     * garbage case is rejected via `Number`. Decimal values are preserved as-is,
+     * so `'12.9'` stays `12.9`.
+     *
+     * Use `Result.unwrapOk` (optionally with a `?? Number.NaN` fallback) or
+     * `Result.unwrapOkOr` to get a plain number back.
+     *
+     * @example
+     *
+     * ```ts
+     * assert.strictEqual(
+     *   Result.unwrapOkOr(Num.safeParseFloat('12.9'), Number.NaN),
+     *   12.9,
+     * );
+     *
+     * assert.strictEqual(
+     *   Result.unwrapOkOr(Num.safeParseFloat('-3.5'), Number.NaN),
+     *   -3.5,
+     * );
+     *
+     * assert.strictEqual(
+     *   Result.unwrapOkOr(Num.safeParseFloat('1e3'), Number.NaN),
+     *   1000,
+     * );
+     *
+     * // Native `parseFloat` ignores trailing non-numeric characters
+     *
+     * assert.strictEqual(Number.parseFloat('12px'), 12);
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('12px')));
+     *
+     * // Whitespace is not a valid number, so we return an error instead of coercing to 0.
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('')));
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('   ')));
+     *
+     * // Infinity and NaN are not finite, so they are rejected.
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('Infinity')));
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('NaN')));
+     * ```
+     *
+     * @param s The string to parse.
+     * @returns `Result.ok(parsedFloat)` for valid finite input, otherwise
+     *   `Result.err` wrapping an `Error` describing the invalid input.
+     */
+    export const safeParseFloat: (s: string) => Result<FiniteNumber, Error>;
     /**
      * Type guard that checks if a number is non-zero.
      *

package/dist/number/num.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"num.d.mts","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"num.d.mts","sourceRoot":"","sources":["../../src/number/num.mts"],"names":[],"mappings":"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"}

package/dist/number/num.mjs

@@ -109,6 +109,82 @@ var Num;
             : // eslint-disable-next-line total-functions/no-unsafe-type-assertion, ts-data-forge/prefer-as-int
                 ok(Math.trunc(viaNumber));
     };
+    /**
+     * Safely parses a finite floating-point number from a string, returning a
+     * {@link Result} that is `Ok<FiniteNumber>` for valid input and `Err<Error>`
+     * otherwise.
+     *
+     * This is a stricter alternative to both `parseFloat` and `Number`:
+     *
+     * - Unlike `parseFloat('12abc')` (which returns `12`), trailing non-numeric
+     *   characters make the whole input invalid and yield `Err`.
+     * - Unlike `Number('')` / `Number('   ')` (which return `0`), empty or
+     *   whitespace-only input yields `Err`.
+     * - Unlike `Number('Infinity')` (which returns `Infinity`), non-finite values
+     *   yield `Err`.
+     *
+     * The empty-string case is rejected by delegating to `parseFloat` (which
+     * returns `NaN` there) rather than hard-coding a check, while the trailing-
+     * garbage case is rejected via `Number`. Decimal values are preserved as-is,
+     * so `'12.9'` stays `12.9`.
+     *
+     * Use `Result.unwrapOk` (optionally with a `?? Number.NaN` fallback) or
+     * `Result.unwrapOkOr` to get a plain number back.
+     *
+     * @example
+     *
+     * ```ts
+     * assert.strictEqual(
+     *   Result.unwrapOkOr(Num.safeParseFloat('12.9'), Number.NaN),
+     *   12.9,
+     * );
+     *
+     * assert.strictEqual(
+     *   Result.unwrapOkOr(Num.safeParseFloat('-3.5'), Number.NaN),
+     *   -3.5,
+     * );
+     *
+     * assert.strictEqual(
+     *   Result.unwrapOkOr(Num.safeParseFloat('1e3'), Number.NaN),
+     *   1000,
+     * );
+     *
+     * // Native `parseFloat` ignores trailing non-numeric characters
+     *
+     * assert.strictEqual(Number.parseFloat('12px'), 12);
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('12px')));
+     *
+     * // Whitespace is not a valid number, so we return an error instead of coercing to 0.
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('')));
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('   ')));
+     *
+     * // Infinity and NaN are not finite, so they are rejected.
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('Infinity')));
+     *
+     * assert.isTrue(Result.isErr(Num.safeParseFloat('NaN')));
+     * ```
+     *
+     * @param s The string to parse.
+     * @returns `Result.ok(parsedFloat)` for valid finite input, otherwise
+     *   `Result.err` wrapping an `Error` describing the invalid input.
+     */
+    Num.safeParseFloat = (s) => {
+        const viaNumber = Number(s);
+        // `Number('')` / `Number('   ')` は 0 を返すが、`parseFloat` は NaN を返す。
+        // 末尾不正文字 ('12abc' 等) は `Number` 側が NaN にするので、両者が共に
+        // 非 NaN かつ有限の場合のみ採用することで空文字・空白のみ・末尾不正・
+        // Infinity をまとめて弾く。
+        return Number.isNaN(viaNumber) ||
+            !Number.isFinite(viaNumber) ||
+            Number.isNaN(Number.parseFloat(s))
+            ? err(new Error(`safeParseFloat: "${s}" is not a valid finite number`))
+            : // eslint-disable-next-line total-functions/no-unsafe-type-assertion, ts-data-forge/prefer-as-int
+                ok(viaNumber);
+    };
     /**
      * Type guard that checks if a number is non-zero.
      *

package/dist/number/num.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"num.mjs","sources":["../../src/number/num.mts"],"sourcesContent":[null],"names":["Result.err","Result.ok"],"mappings":";;;;AAqBA;;;;;;;;;;;;;;AAcG;IACc;AAAjB,CAAA,UAAiB,GAAG,EAAA;AAClB;;;;;;;;;;;;;;;AAeG;IACU,GAAA,CAAA,IAAI,GAA2B,MAAM;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DG;AACU,IAAA,GAAA,CAAA,YAAY,GAAG,CAAC,CAAS,KAAwB;AAC5D,QAAA,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC;;;;AAK3B,QAAA,OAAO,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC;AACnE,cAAEA,GAAU,CACR,IAAI,KAAK,CAAC,CAAA,eAAA,EAAkB,CAAC,CAAA,gCAAA,CAAkC,CAAC;AAEpE;gBACEC,EAAS,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAQ,CAAC;AAC7C,IAAA,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;IACU,GAAA,CAAA,SAAS,GAAG,CACvB,GAAM,KAC0C,GAAG,KAAK,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;IACU,GAAA,CAAA,aAAa,GAAG,CAC3B,GAAM,KAEN,GAAG,IAAI,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;AAsBG;IACU,GAAA,CAAA,UAAU,GAAG,CACxB,GAAM,KAEN,GAAG,GAAG,CAAC;AAET;;;;;;;;;;;;;;;;;;AAkBG;IACU,GAAA,CAAA,SAAS,GACpB,CAAC,UAAkB,EAAE,UAAkB,KACvC,CAAC,CAAS,KACR,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU;AAErC;;;;;;;;;;;;;;;;;;AAkBG;IACU,GAAA,CAAA,kBAAkB,GAC7B,CAAC,UAAkB,EAAE,UAAkB,KACvC,CAAC,CAAS,KACR,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU;AA0BtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;IACU,GAAA,CAAA,aAAa,GACxB,CAA2C,UAAa,EAAE,UAAa,KACvE,CAAC,CAAS,KACR,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;IACU,GAAA,CAAA,sBAAsB,GACjC,CAA2C,UAAa,EAAE,UAAa,KACvE,CAAC,CAAS,KACR,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,UAAU,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU;IAsCjE,SAAgB,KAAK,CACnB,GAAG,IAEkD,EAAA;AAErD,QAAA,QAAQ,IAAI,CAAC,MAAM;YACjB,KAAK,CAAC,EAAE;gBACN,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,GAAG,IAAI;AAE7C,gBAAA,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM;AAC5B,sBAAE;AACF,sBAAE,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;;YAGxD,KAAK,CAAC,EAAE;AACN,gBAAA,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG,IAAI;AAErC,gBAAA,OAAO,CAAC,MAAc,KACpB,KAAK,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;;;;AAlB7B,IAAA,GAAA,CAAA,KAAK,QAqBpB;AAED;;;;;;;;;;AAUG;AACU,IAAA,GAAA,CAAA,GAAG,GAAG,CAAC,CAAS,EAAE,CAAkC;;IAE/D,CAAC,GAAG,CAAC;AAEP;;;;;;;;;;;;AAYG;AACU,IAAA,GAAA,CAAA,MAAM,GAAG,CACpB,CAAS,EACT,CAAkC;;AAGlC,IAAA,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAE3C;;;;;;;;;AASG;AACU,IAAA,GAAA,CAAA,OAAO,GAAG,CACrB,GAAW,EACX,SAAsC,KAC5B;AACV,QAAA,MAAM,KAAK,GAAG,EAAE,IAAI,SAAS;;QAG7B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,KAAK;AACxC,IAAA,CAAC;AAED;;;;;;;;;AASG;;AAEU,IAAA,GAAA,CAAA,UAAU,GAAG,CAAC,GAAW,KAAU,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAQ;AAE5E;;;;;;;;;AASG;AACU,IAAA,GAAA,CAAA,KAAK,GAAG,CACnB,KAAkC,KACL;AAC7B,QAAA,MAAM,SAAS,GAAG,EAAE,IAAI,KAAK;QAE7B,OAAO,CAAC,MAAc;;QAEpB,GAAA,CAAA,UAAU,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,SAAS;AAC9C,IAAA,CAAC;AAED;;;;;;;;;;AAUG;IACU,GAAA,CAAA,gBAAgB,GAAG,CAC9B,GAAM,KAEN,MAAM,CAAC,KAAK,CAAC,GAAG;AACd,UAAE;AACF;AACG,YAAA,GAAkC;AAEzC;;;;;;;;;;AAUG;AACU,IAAA,GAAA,CAAA,SAAS,GAAG,CAAsB,CAAI;;AAEjD,KAAC,CAAC,GAAG,CAAC,CAAiB;AAEzB;;;;;;;;;;AAUG;AACU,IAAA,GAAA,CAAA,SAAS,GAAG,CAA6B,CAAI;;AAExD,KAAC,CAAC,GAAG,CAAC,CAAiB;AAC3B,CAAC,EA5gBgB,GAAG,KAAH,GAAG,GAAA,EAAA,CAAA,CAAA;;;;"}
+{"version":3,"file":"num.mjs","sources":["../../src/number/num.mts"],"sourcesContent":[null],"names":["Result.err","Result.ok"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "6.12.0",
+  "version": "6.13.1",
   "private": false,
   "keywords": [
     "typescript",
@@ -42,6 +42,9 @@
     "clean": "pnpm run /clean:.*/",
     "clean:logs": "npx rimraf ./*.log",
     "codemod": "run-s codemod:uncommitted:as-const fmt codemod:uncommitted:readonly fmt",
+    "codemod:diff": "run-s codemod:diff:as-const fmt codemod:diff:readonly fmt",
+    "codemod:diff:as-const": "append-as-const --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
+    "codemod:diff:readonly": "convert-to-readonly --diff-from origin/main '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:full": "run-s codemod:full:as-const fmt codemod:full:readonly fmt",
     "codemod:full:as-const": "append-as-const '{src,scripts,samples,test}/**/*.{mts,tsx}'",
     "codemod:full:readonly": "convert-to-readonly '{src,scripts,samples,test}/**/*.{mts,tsx}'",

package/src/functional/pipe.mts

@@ -1,4 +1,4 @@
-import { type MergeIntersection } from 'ts-type-forge';
+import { expectType } from '../expect-type.mjs';
 import { Optional, type UnknownOptional } from './optional/index.mjs';
 
 /**
@@ -19,36 +19,71 @@ import { Optional, type UnknownOptional } from './optional/index.mjs';
  * @param a The initial value to wrap in a pipe.
  * @returns A pipe object with chaining methods appropriate for the value type.
  */
-export function pipe<const A extends UnknownOptional>(
-  a: A,
-): PipeWithMapOptional<A>;
-
-export function pipe<const A>(a: A): PipeBase<A>;
-
-export function pipe<const A>(a: A): PipeImpl<A> {
-  if (Optional.isOptional(a)) {
-    return {
-      value: a,
-      map: (fn) => pipe(fn(a)),
-      mapOptional: (fn) => pipe(Optional.map(a, fn)),
-    };
-  } else {
-    return {
-      value: a,
-      map: (fn) => pipe(fn(a)),
-      mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
-    };
-  }
-}
-
-type Pipe<A> = A extends UnknownOptional ? PipeWithMapOptional<A> : PipeBase<A>;
+export const pipe = <const A,>(a: A): Pipe<A> =>
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  ({
+    value: a,
+    map: (fn) => pipe(fn(a)),
+    mapNullable: (fn) => pipe(a == null ? undefined : fn(a)),
+
+    ...(Optional.isOptional(a)
+      ? {
+          mapOptional: (fn) => pipe(Optional.map(a, fn)),
+        }
+      : {}),
+  }) satisfies PipeImpl<A> as unknown as Pipe<A>;
+
+// `PipeBase<A>` is always present; the conditional only *adds* `mapOptional`
+// for Optional values. Two subtleties motivate this shape:
+//
+//   1. The check is `[A] extends [UnknownOptional]` (a 1-tuple), not the bare
+//      `A extends UnknownOptional`. A bare check distributes over unions, so a
+//      piped union value such as `Result<D, E> | undefined` would expand into
+//      `Pipe<Ok<D>> | Pipe<Err<E>> | Pipe<undefined>`. Calling a chained method
+//      on that union of pipe objects forces TypeScript to synthesize a merged
+//      call signature, during which a branded member like `Ok<D>` is widened to
+//      its constraint (`Ok<number>`) — losing the brand `D`.
+//
+//   2. `value: A` lives on `PipeBase<A>`, *outside* the conditional. If `value`
+//      flowed through the conditional, then for a not-yet-resolved generic `A`
+//      the deferred true branch narrows `A` to `A & UnknownOptional`, so
+//      `.value` would surface as the noisy `(A & UnknownOptional) | A`. Keeping
+//      it on the unconditional base yields a clean `A`.
+// transformer-ignore-next-line convert-to-readonly
+export type Pipe<A> = PipeBase<A> &
+  PipeMapNullable<A> &
+  ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown);
+
+// NOTE: 以下では 'typing when used with generics' test で型エラーが出る。
+// 詳細は documents/reports/pipe-typing.md の 「mapNullable を条件付きで含めるのがうまくいかない理由」を参照。
+// export type Pipe<A> = PipeBase<A> &
+//   ([A] extends [UnknownOptional] ? PipeMapOptional<A> : unknown) &
+//   ([undefined] extends [A] ? PipeMapNullable<A> : unknown) &
+//   ([null] extends [A] ? PipeMapNullable<A> : unknown);
+
+expectType<Optional<number>, UnknownOptional>('<=');
+
+expectType<number | undefined, undefined>('>=');
+
+expectType<keyof Pipe<number | undefined>, 'value' | 'map' | 'mapNullable'>(
+  '=',
+);
+
+expectType<
+  keyof Pipe<Optional<number>>,
+  'value' | 'map' | 'mapNullable' | 'mapOptional'
+>('=');
+
+expectType<
+  keyof Pipe<Optional<number | undefined>>,
+  'value' | 'map' | 'mapNullable' | 'mapOptional'
+>('=');
+
+expectType<
+  keyof Pipe<Optional<number> | undefined>,
+  'value' | 'map' | 'mapNullable'
+>('=');
 
-/**
- * @template A The type of the current value in the pipe.
- * @internal
- * Base pipe interface providing core functionality.
- * All pipe types extend this interface.
- */
 type PipeBase<A> = Readonly<{
   /** The current value being piped. */
   value: A;
@@ -71,7 +106,9 @@ type PipeBase<A> = Readonly<{
    * @returns A new pipe containing the transformed value.
    */
   map: <B>(fn: (a: A) => B) => Pipe<B>;
+}>;
 
+type PipeMapNullable<A> = Readonly<{
   /**
    * Maps the current value only if it's not null or undefined. If the current
    * value is null/undefined, the transformation is skipped and undefined is
@@ -100,56 +137,45 @@ type PipeBase<A> = Readonly<{
   mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;
 }>;
 
-/**
- * @template A The Optional type currently in the pipe.
- * @internal
- * Pipe interface for Optional values, providing Optional-aware mapping.
- * Extends PipeBase with mapOptional functionality for monadic operations.
- */
-type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<
-  PipeBase<A> &
-    Readonly<{
-      /**
-       * Maps the value inside an Optional using Optional.map semantics. If the
-       * Optional is None, the transformation is skipped and None is propagated.
-       * If the Optional is Some, the transformation is applied to the inner
-       * value.
-       *
-       * @example
-       *
-       * ```ts
-       * const result = pipe(Optional.some(10))
-       *   .mapOptional((value) => value * 2)
-       *   .mapOptional((value) => value + 5);
-       *
-       * assert.deepStrictEqual(result.value, Optional.some(25));
-       *
-       * const empty = pipe(Optional.none as Optional<number>).mapOptional(
-       *   (value) => value * 2,
-       * );
-       *
-       * assert.isTrue(Optional.isNone(empty.value));
-       * ```
-       *
-       * @template B The type of the transformed inner value.
-       * @param fn Function to transform the inner value of the Optional.
-       * @returns A new pipe containing an Optional with the transformed value.
-       */
-      mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;
-    }>
->;
+type PipeMapOptional<A extends UnknownOptional> = Readonly<{
+  /**
+   * Maps the value inside an Optional using Optional.map semantics. If the
+   * Optional is None, the transformation is skipped and None is propagated.
+   * If the Optional is Some, the transformation is applied to the inner
+   * value.
+   *
+   * @example
+   *
+   * ```ts
+   * const result = pipe(Optional.some(10))
+   *   .mapOptional((value) => value * 2)
+   *   .mapOptional((value) => value + 5);
+   *
+   * assert.deepStrictEqual(result.value, Optional.some(25));
+   *
+   * const empty = pipe(Optional.none as Optional<number>).mapOptional(
+   *   (value) => value * 2,
+   * );
+   *
+   * assert.isTrue(Optional.isNone(empty.value));
+   * ```
+   *
+   * @template B The type of the transformed inner value.
+   * @param fn Function to transform the inner value of the Optional.
+   * @returns A new pipe containing an Optional with the transformed value.
+   */
+  mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;
+}>;
 
 /** @internal */
 type Cast<T, U> = T & U;
 
 /** @internal */
-type PipeImpl<A> = Partial<
-  Readonly<{
-    value: A;
-    map: <B>(fn: (a: A) => B) => PipeBase<B>;
-    mapNullable: <B>(fn: (a: NonNullable<A>) => B) => PipeBase<B | undefined>;
-    mapOptional: <B>(
-      fn: (a: Optional.Unwrap<Cast<A, UnknownOptional>>) => B,
-    ) => PipeBase<Optional<B>>;
-  }>
->;
+type PipeImpl<A> = Readonly<{
+  value: A;
+  map: <B>(fn: (a: A) => B) => PipeImpl<B>;
+  mapNullable?: <B>(fn: (a: NonNullable<A>) => B) => PipeImpl<B | undefined>;
+  mapOptional?: <B>(
+    fn: (a: Optional.Unwrap<Cast<A, UnknownOptional>>) => B,
+  ) => PipeImpl<Optional<B>>;
+}>;

package/src/functional/pipe.test.mts

@@ -2,6 +2,7 @@ import { expectType } from '../expect-type.mjs';
 import { type None, type Some } from '../types.mjs';
 import { Optional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
+import { Result } from './result/index.mjs';
 
 describe(pipe, () => {
   test('basic pipe operations', () => {
@@ -35,7 +36,9 @@ describe(pipe, () => {
   });
 
   test('mapNullable with non-null value', () => {
-    const result = pipe(5 as number | null).mapNullable((x) => x * 2).value;
+    const s = 5 as number | null;
+
+    const result = pipe(s).mapNullable((x) => x * 2).value;
 
     expect(result).toBe(10);
 
@@ -95,4 +98,57 @@ describe(pipe, () => {
 
     expectType<typeof result, string>('=');
   });
+
+  test('typing when used with Result', () => {
+    const validate = <D,>(_u: unknown): Result<D, unknown> =>
+      Result.err(undefined);
+
+    const decodeBranded = (
+      input: string,
+      parse: (s: string) => number | undefined,
+    ): number | undefined => {
+      const v = pipe(input)
+        .map(parse)
+        .mapNullable(validate<number>)
+        .mapNullable((res) => Result.unwrapOk(res)).value;
+
+      expectType<typeof v, number | undefined>('=');
+
+      return v;
+    };
+
+    expect(decodeBranded('', () => undefined)).toBeUndefined();
+  });
+
+  test('typing when used with generics', () => {
+    const validate = <D,>(_u: unknown): Result<D, unknown> =>
+      Result.err(undefined);
+
+    // Regression: a generic brand `D` must survive the whole chain.
+    //
+    // The trigger is a `.map` whose result is a branded *union* such as
+    // `D | undefined`. If `Pipe<A>` distributes over unions, that step expands
+    // into `Pipe<D> | Pipe<undefined>`; calling the next method on the union of
+    // pipe objects then widens `D` to its constraint `number`, so `.value`
+    // collapses to `number | undefined` instead of `D | undefined`.
+    //
+    // The explicit `D | undefined` return annotation is itself the assertion:
+    // were the brand lost, `.value` would be `number | undefined` and the
+    // body would fail to compile.
+    const decodeBranded = <D extends number>(
+      input: string,
+      parse: (s: string) => D | undefined,
+    ): D | undefined => {
+      const v = pipe(input)
+        .map(parse)
+        .mapNullable((n) => validate<D>(n))
+        .mapNullable((res) => Result.unwrapOk(res)).value;
+
+      expectType<typeof v, D | undefined>('=');
+
+      return v;
+    };
+
+    expect(decodeBranded('', () => undefined)).toBeUndefined();
+  });
 });

package/src/number/num.mts

@@ -1,5 +1,6 @@
 import {
   type Decrement,
+  type FiniteNumber,
   type Increment,
   type Index,
   type Int,
@@ -130,6 +131,86 @@ export namespace Num {
         Result.ok(Math.trunc(viaNumber) as Int);
   };
 
+  /**
+   * Safely parses a finite floating-point number from a string, returning a
+   * {@link Result} that is `Ok<FiniteNumber>` for valid input and `Err<Error>`
+   * otherwise.
+   *
+   * This is a stricter alternative to both `parseFloat` and `Number`:
+   *
+   * - Unlike `parseFloat('12abc')` (which returns `12`), trailing non-numeric
+   *   characters make the whole input invalid and yield `Err`.
+   * - Unlike `Number('')` / `Number('   ')` (which return `0`), empty or
+   *   whitespace-only input yields `Err`.
+   * - Unlike `Number('Infinity')` (which returns `Infinity`), non-finite values
+   *   yield `Err`.
+   *
+   * The empty-string case is rejected by delegating to `parseFloat` (which
+   * returns `NaN` there) rather than hard-coding a check, while the trailing-
+   * garbage case is rejected via `Number`. Decimal values are preserved as-is,
+   * so `'12.9'` stays `12.9`.
+   *
+   * Use `Result.unwrapOk` (optionally with a `?? Number.NaN` fallback) or
+   * `Result.unwrapOkOr` to get a plain number back.
+   *
+   * @example
+   *
+   * ```ts
+   * assert.strictEqual(
+   *   Result.unwrapOkOr(Num.safeParseFloat('12.9'), Number.NaN),
+   *   12.9,
+   * );
+   *
+   * assert.strictEqual(
+   *   Result.unwrapOkOr(Num.safeParseFloat('-3.5'), Number.NaN),
+   *   -3.5,
+   * );
+   *
+   * assert.strictEqual(
+   *   Result.unwrapOkOr(Num.safeParseFloat('1e3'), Number.NaN),
+   *   1000,
+   * );
+   *
+   * // Native `parseFloat` ignores trailing non-numeric characters
+   *
+   * assert.strictEqual(Number.parseFloat('12px'), 12);
+   *
+   * assert.isTrue(Result.isErr(Num.safeParseFloat('12px')));
+   *
+   * // Whitespace is not a valid number, so we return an error instead of coercing to 0.
+   *
+   * assert.isTrue(Result.isErr(Num.safeParseFloat('')));
+   *
+   * assert.isTrue(Result.isErr(Num.safeParseFloat('   ')));
+   *
+   * // Infinity and NaN are not finite, so they are rejected.
+   *
+   * assert.isTrue(Result.isErr(Num.safeParseFloat('Infinity')));
+   *
+   * assert.isTrue(Result.isErr(Num.safeParseFloat('NaN')));
+   * ```
+   *
+   * @param s The string to parse.
+   * @returns `Result.ok(parsedFloat)` for valid finite input, otherwise
+   *   `Result.err` wrapping an `Error` describing the invalid input.
+   */
+  export const safeParseFloat = (s: string): Result<FiniteNumber, Error> => {
+    const viaNumber = Number(s);
+
+    // `Number('')` / `Number('   ')` は 0 を返すが、`parseFloat` は NaN を返す。
+    // 末尾不正文字 ('12abc' 等) は `Number` 側が NaN にするので、両者が共に
+    // 非 NaN かつ有限の場合のみ採用することで空文字・空白のみ・末尾不正・
+    // Infinity をまとめて弾く。
+    return Number.isNaN(viaNumber) ||
+      !Number.isFinite(viaNumber) ||
+      Number.isNaN(Number.parseFloat(s))
+      ? Result.err(
+          new Error(`safeParseFloat: "${s}" is not a valid finite number`),
+        )
+      : // eslint-disable-next-line total-functions/no-unsafe-type-assertion, ts-data-forge/prefer-as-int
+        Result.ok(viaNumber as FiniteNumber);
+  };
+
   /**
    * Type guard that checks if a number is non-zero.
    *

package/src/number/num.test.mts

@@ -190,6 +190,68 @@ describe('Num test', () => {
     });
   });
 
+  describe('safeParseFloat', () => {
+    test('parses valid numeric strings into Ok', () => {
+      expect(Result.unwrapOk(Num.safeParseFloat('123'))).toBe(123);
+
+      expect(Result.unwrapOk(Num.safeParseFloat('-42'))).toBe(-42);
+
+      expect(Result.unwrapOk(Num.safeParseFloat('+7'))).toBe(7);
+
+      expect(Result.unwrapOk(Num.safeParseFloat('0'))).toBe(0);
+
+      expect(Result.unwrapOk(Num.safeParseFloat('  12  '))).toBe(12);
+    });
+
+    test('preserves decimal values', () => {
+      expect(Result.unwrapOk(Num.safeParseFloat('12.9'))).toBe(12.9);
+
+      expect(Result.unwrapOk(Num.safeParseFloat('-3.5'))).toBe(-3.5);
+
+      expect(Result.unwrapOk(Num.safeParseFloat('1e3'))).toBe(1000);
+    });
+
+    test('rejects trailing non-numeric characters (unlike parseFloat)', () => {
+      assert.isTrue(Result.isErr(Num.safeParseFloat('123abc')));
+
+      assert.isTrue(Result.isErr(Num.safeParseFloat('12px')));
+
+      assert.isTrue(Result.isErr(Num.safeParseFloat('abc')));
+    });
+
+    test('rejects empty / whitespace-only input (unlike Number)', () => {
+      assert.isTrue(Result.isErr(Num.safeParseFloat('')));
+
+      assert.isTrue(Result.isErr(Num.safeParseFloat('   ')));
+    });
+
+    test('rejects non-finite values', () => {
+      assert.isTrue(Result.isErr(Num.safeParseFloat('Infinity')));
+
+      assert.isTrue(Result.isErr(Num.safeParseFloat('-Infinity')));
+
+      assert.isTrue(Result.isErr(Num.safeParseFloat('NaN')));
+    });
+
+    test('the Err carries a descriptive Error', () => {
+      const result = Num.safeParseFloat('nope');
+
+      assert.isTrue(Result.isErr(result));
+
+      if (Result.isErr(result)) {
+        expect(Result.unwrapErr(result)).toBeInstanceOf(Error);
+      }
+    });
+
+    test('composes with Result.unwrapOk + nullish fallback', () => {
+      expect(Result.unwrapOk(Num.safeParseFloat('3.14')) ?? Number.NaN).toBe(
+        3.14,
+      );
+
+      expect(Result.unwrapOk(Num.safeParseFloat('')) ?? Number.NaN).toBeNaN();
+    });
+  });
+
   describe('isInRange', () => {
     test('checks range (lower inclusive, upper exclusive)', () => {
       const inRange = Num.isInRange(0, 10);

package/src/others/map-nullable.test.mts

@@ -143,10 +143,9 @@ describe(mapNullable, () => {
 
       const toUpperCase = mapNullable((s: string) => s.toUpperCase());
 
-      const result = pipe(42 as number | null)
-        .map(toStr)
-        .map(addPrefix)
-        .map(toUpperCase).value;
+      const x = 42 as number | null;
+
+      const result = pipe(x).map(toStr).map(addPrefix).map(toUpperCase).value;
 
       expect(result).toBe('NUMBER: 42');
     });