ts-data-forge 6.13.1 → 7.0.1

package/src/collections/imap-mapped.test.mts

@@ -1,5 +1,6 @@
 import { type DeepReadonly } from 'ts-type-forge';
-import { Optional } from '../functional/index.mjs';
+import { Optional, Result } from '../functional/index.mjs';
+import { Num } from '../number/index.mjs';
 import { IMapMapped } from './imap-mapped.mjs';
 
 const toKey = (a: Readonly<{ v: number }>): number => a.v;
@@ -14,7 +15,10 @@ const testKeyToString = (key: Readonly<TestKey>): string =>
 const stringToTestKey = (str: string): TestKey => {
   const [type, idStr] = str.split('_');
 
-  return { type: type ?? '', id: Number(idStr ?? '0') };
+  return {
+    type: type ?? '',
+    id: Result.unwrapOkOr(Num.safeParseFloat(idStr ?? '0'), Number.NaN),
+  };
 };
 
 describe('IMapMapped[Symbol.iterator]', () => {
@@ -112,7 +116,9 @@ describe('IMapMapped.create', () => {
       const [idStr, arrStr] = str.split('_');
 
       return {
-        nested: { id: Number(idStr ?? '0') },
+        nested: {
+          id: Result.unwrapOkOr(Num.safeParseFloat(idStr ?? '0'), Number.NaN),
+        },
         arr: (arrStr ?? '').split(',').map(Number),
       };
     };
@@ -222,6 +228,31 @@ describe('IMapMapped.equal', () => {
 
     assert.isTrue(IMapMapped.equal(map1, map2));
   });
+
+  test('should return true for non-empty maps with identical entries', () => {
+    // Regression: the old implementation compared `b.get(k) === v` where
+    // `b.get(k)` returns `Optional<V>` and `v` is `V`, so the comparison was
+    // always false and `equal` never returned true for non-empty maps.
+    const map1 = IMapMapped.create(
+      [
+        [{ id: 1, type: 'user' }, 'Alice'],
+        [{ id: 2, type: 'admin' }, 'Bob'],
+      ],
+      testKeyToString,
+      stringToTestKey,
+    );
+
+    const map2 = IMapMapped.create(
+      [
+        [{ id: 2, type: 'admin' }, 'Bob'],
+        [{ id: 1, type: 'user' }, 'Alice'],
+      ],
+      testKeyToString,
+      stringToTestKey,
+    );
+
+    assert.isTrue(IMapMapped.equal(map1, map2));
+  });
 });
 
 describe('IMapMapped.size', () => {
@@ -398,6 +429,26 @@ describe('IMapMapped.set', () => {
     );
   });
 
+  test('should return same instance when setting an existing key with the same value', () => {
+    // Regression: the old implementation compared `value === this.get(key)`
+    // where `this.get(key)` returns `Optional<V>` and `value` is `V`, so the
+    // comparison was always false and the early return never fired — a new
+    // instance was always created even when the value was unchanged.
+    const s0 = IMapMapped.create(
+      [
+        [{ v: 1 }, '1'],
+        [{ v: 2 }, '2'],
+        [{ v: 3 }, '3'],
+      ],
+      toKey,
+      fromKey,
+    );
+
+    const result = s0.set({ v: 3 }, '3');
+
+    assert.isTrue(result === s0);
+  });
+
   test('case 3', () => {
     const s0 = IMapMapped.create<Readonly<{ v: number }>, string, number>(
       [],
@@ -602,7 +653,6 @@ describe('IMapMapped.some', () => {
       stringToTestKey,
     );
 
-    // eslint-disable-next-line unicorn/prefer-includes
     assert.isTrue(map.some((value) => value === 'Alice'));
   });
 
@@ -616,7 +666,6 @@ describe('IMapMapped.some', () => {
       stringToTestKey,
     );
 
-    // eslint-disable-next-line unicorn/prefer-includes
     assert.isFalse(map.some((value) => value === 'Charlie'));
   });
 
@@ -799,17 +848,16 @@ describe('IMapMapped.forEach', () => {
       stringToTestKey,
     );
 
-    const mut_collected: [TestKey, string][] = [];
-
-    for (const [key, value] of map.entries()) {
-      mut_collected.push([key, value]);
-    }
+    const collected: DeepReadonly<[TestKey, string][]> = Array.from(
+      map.entries(),
+      ([key, value]) => [key, value],
+    );
 
-    expect(mut_collected).toHaveLength(2);
+    expect(collected).toHaveLength(2);
 
-    expect(mut_collected).toContainEqual([{ id: 1, type: 'user' }, 'Alice']);
+    expect(collected).toContainEqual([{ id: 1, type: 'user' }, 'Alice']);
 
-    expect(mut_collected).toContainEqual([{ id: 2, type: 'admin' }, 'Bob']);
+    expect(collected).toContainEqual([{ id: 2, type: 'admin' }, 'Bob']);
   });
 });
 

package/src/collections/imap.mts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/prefer-iterator-to-array-at-end */
 import { type WidenLiteral } from 'ts-type-forge';
 import { Optional, pipe } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
@@ -87,7 +88,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * ```
    *
    * @param key The key to retrieve.
-   * @returns The value associated with the key wrapped with Optional.some, or
+   * @returns The value associated with the key wrapped with `Optional.some`, or
    *   `Optional.none` if the key does not exist.
    */
   get: (key: K | (WidenLiteral<K> & {})) => Optional<V>;
@@ -390,9 +391,9 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    *
    * const mut_entries: (readonly [string, number])[] = [];
    *
-   * for (const [key, value] of map.entries()) {
+   * map.forEach((value, key) => {
    *   mut_entries.push([key, value]);
-   * }
+   * });
    *
    * assert.deepStrictEqual(mut_entries, [
    *   ['a', 1],
@@ -815,11 +816,11 @@ class IMapClass<K extends MapSetKeyType, V>
 
     if (!this.has(key)) {
       return IMap.create([...this.#map, tp(key, value)]);
-    } else {
-      return IMap.create(
-        Array.from(this.#map, ([k, v]) => tp(k, Object.is(k, key) ? value : v)),
-      );
     }
+
+    return IMap.create(
+      Array.from(this.#map, ([k, v]) => tp(k, Object.is(k, key) ? value : v)),
+    );
   }
 
   /** @inheritdoc */
@@ -853,7 +854,13 @@ class IMapClass<K extends MapSetKeyType, V>
   ): IMap<K, V> {
     const mut_result = new Map<K, V>(this.#map);
 
-    for (const action of actions) {
+    const updateFn = (
+      action: Readonly<
+        | { type: 'delete'; key: K }
+        | { type: 'set'; key: K; value: V }
+        | { type: 'update'; key: K; updater: (value: V) => V }
+      >,
+    ): void => {
       switch (action.type) {
         case 'delete':
           mut_result.delete(action.key);
@@ -885,6 +892,10 @@ class IMapClass<K extends MapSetKeyType, V>
           break;
         }
       }
+    };
+
+    for (const action of actions) {
+      updateFn(action);
     }
 
     return IMap.create(mut_result);
@@ -909,7 +920,7 @@ class IMapClass<K extends MapSetKeyType, V>
 
   /** @inheritdoc */
   forEach(callbackfn: (value: V, key: K) => void): void {
-    for (const [key, value] of this.#map.entries()) {
+    for (const [key, value] of this.#map) {
       callbackfn(value, key);
     }
   }

package/src/collections/imap.test.mts

@@ -1,5 +1,6 @@
-import { Optional } from '../functional/index.mjs';
+import { Optional, Result } from '../functional/index.mjs';
 import { isString } from '../guard/index.mjs';
+import { Num } from '../number/index.mjs';
 import { IMap } from './imap.mjs';
 
 describe('IMap[Symbol.iterator]', () => {
@@ -829,7 +830,9 @@ describe('IMap.mapKeys', () => {
       ['2', 'two'],
     ]);
 
-    const mapped = map.mapKeys((key) => Number.parseInt(key, 10));
+    const mapped = map.mapKeys((key) =>
+      Result.unwrapOkOr(Num.safeParseInt(key), Number.NaN),
+    );
 
     expect(Optional.unwrap(mapped.get(1))).toBe('one');
 
@@ -896,11 +899,10 @@ describe('IMap.forEach', () => {
       ['c', 3],
     ]);
 
-    const mut_collected: [string, number][] = [];
-
-    for (const [key, value] of map.entries()) {
-      mut_collected.push([key, value]);
-    }
+    const mut_collected: [string, number][] = Array.from(
+      map.entries(),
+      ([key, value]) => [key, value],
+    );
 
     expect(mut_collected).toHaveLength(3);
 
@@ -916,7 +918,6 @@ describe('IMap.forEach', () => {
 
     let mut_called = false;
 
-    // eslint-disable-next-line unicorn/no-array-for-each
     map.forEach(() => {
       mut_called = true;
     });

package/src/collections/iset-mapped.mts

@@ -1,4 +1,5 @@
-import { type ReadonlyRecord } from 'ts-type-forge';
+/* eslint-disable unicorn/prefer-iterator-to-array-at-end */
+import { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
 
@@ -126,7 +127,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    * @param key The element to check.
    * @returns `true` if the element exists, `false` otherwise.
    */
-  has: (key: K) => boolean;
+  has: (key: K | (WidenLiteral<K> & {})) => boolean;
 
   // Reducing a value
 
@@ -471,9 +472,9 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *
    * const mut_collected: Point[] = [];
    *
-   * for (const point of set) {
+   * set.forEach((point) => {
    *   mut_collected.push(point);
-   * }
+   * });
    *
    * assert.deepStrictEqual(mut_collected, [
    *   { x: 1, tag: 'a' },
@@ -1218,8 +1219,9 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
   }
 
   /** @inheritdoc */
-  has(key: K): boolean {
-    return this.#set.has(this.#toKey(key));
+  has(key: K | (WidenLiteral<K> & {})): boolean {
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return this.#set.has(this.#toKey(key as K));
   }
 
   /** @inheritdoc */
@@ -1290,7 +1292,9 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
   ): ISetMapped<K, KM> {
     const mut_result = new Set<KM>(this.#set);
 
-    for (const action of actions) {
+    const updateFn = (
+      action: Readonly<{ type: 'add'; key: K } | { type: 'delete'; key: K }>,
+    ): void => {
       const key = this.#toKey(action.key);
 
       switch (action.type) {
@@ -1304,6 +1308,10 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
 
           break;
       }
+    };
+
+    for (const action of actions) {
+      updateFn(action);
     }
 
     return ISetMapped.create<K, KM>(
@@ -1422,14 +1430,14 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
 
   /** @inheritdoc */
   *keys(): IterableIterator<K> {
-    for (const km of this.#set.keys()) {
+    for (const km of this.#set) {
       yield this.#fromKey(km);
     }
   }
 
   /** @inheritdoc */
   *values(): IterableIterator<K> {
-    for (const km of this.#set.keys()) {
+    for (const km of this.#set) {
       // JavaScript Set's values() is an alias for keys()
       yield this.#fromKey(km);
     }
@@ -1437,7 +1445,7 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
 
   /** @inheritdoc */
   *entries(): IterableIterator<readonly [K, K]> {
-    for (const km of this.#set.keys()) {
+    for (const km of this.#set) {
       // JavaScript Set's entries() yields [value, value]
       const a = this.#fromKey(km);
 

package/src/collections/iset-mapped.test.mts

@@ -1,3 +1,5 @@
+import { Result } from '../functional/index.mjs';
+import { Num } from '../number/index.mjs';
 import { ISetMapped } from './iset-mapped.mjs';
 
 const toKey = (a: Readonly<{ v: number }>): number => a.v;
@@ -13,7 +15,10 @@ const testElementToString = (el: Readonly<TestElement>): string =>
 const stringToTestElement = (str: string): TestElement => {
   const [type, idStr] = str.split('_');
 
-  return { type: type ?? '', id: Number(idStr ?? '0') };
+  return {
+    type: type ?? '',
+    id: Result.unwrapOkOr(Num.safeParseFloat(idStr ?? '0'), Number.NaN),
+  };
 };
 
 describe('ISetMapped[Symbol.iterator]', () => {

package/src/collections/iset.mts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/prefer-iterator-to-array-at-end */
 import { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
 import { unknownToString } from '../others/index.mjs';
@@ -394,9 +395,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * const mut_collected: string[] = [];
    *
-   * for (const value of set) {
+   * set.forEach((value) => {
    *   mut_collected.push(value);
-   * }
+   * });
    *
    * assert.deepStrictEqual(mut_collected, ['alpha', 'beta']);
    * ```
@@ -806,7 +807,9 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
   ): ISet<K> {
     const mut_result = new Set<K>(this.#set);
 
-    for (const action of actions) {
+    const updateFn = (
+      action: Readonly<{ type: 'add'; key: K } | { type: 'delete'; key: K }>,
+    ): void => {
       switch (action.type) {
         case 'delete':
           mut_result.delete(action.key);
@@ -818,6 +821,10 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
 
           break;
       }
+    };
+
+    for (const action of actions) {
+      updateFn(action);
     }
 
     return ISet.create(mut_result);
@@ -846,7 +853,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
 
   /** @inheritdoc */
   forEach(callbackfn: (key: K) => void): void {
-    for (const v of this.#set.values()) {
+    for (const v of this.#set) {
       callbackfn(v);
     }
   }

package/src/collections/iset.test.mts

@@ -1,4 +1,4 @@
-import { type Primitive } from 'ts-type-forge';
+import { type DeepReadonly, type Primitive } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { isString } from '../guard/index.mjs';
 import { type MapSetKeyType } from '../types.mjs';
@@ -922,7 +922,6 @@ describe('ISet.forEach', () => {
 
     let mut_callCount = 0;
 
-    // eslint-disable-next-line unicorn/no-array-for-each
     set.forEach(() => {
       mut_callCount += 1;
     });
@@ -978,14 +977,13 @@ describe('ISet.entries', () => {
       () => IterableIterator<readonly [1 | 2 | 3, 1 | 2 | 3]>
     >('<=');
 
-    const mut_result: [1 | 2 | 3, 1 | 2 | 3][] = [];
-
-    for (const x of s0.entries()) {
-      mut_result.push([x[0], x[1]]);
-    }
+    const result: DeepReadonly<[1 | 2 | 3, 1 | 2 | 3][]> = Array.from(
+      s0.entries(),
+      (x) => [x[0], x[1]],
+    );
 
     assert.deepStrictEqual(
-      mut_result.toSorted((a, b) => a[0] - b[0]),
+      result.toSorted((a, b) => a[0] - b[0]),
       [
         [1, 1],
         [2, 2],

package/src/collections/queue.mts

@@ -205,6 +205,9 @@ export type Queue<T> = Readonly<{
  * @implements Queue
  */
 class QueueClass<T> implements Queue<T> {
+  /** @internal Initial capacity for new queues. */
+  static readonly #INITIAL_CAPACITY = 8;
+
   /** @internal Circular buffer to store queue elements. */
   #mut_buffer: (T | undefined)[];
 
@@ -220,9 +223,6 @@ class QueueClass<T> implements Queue<T> {
   /** @internal Current capacity of the buffer. */
   #mut_capacity: number;
 
-  /** @internal Initial capacity for new queues. */
-  static readonly #INITIAL_CAPACITY = 8;
-
   /**
    * Constructs a new QueueClass instance.
    *
@@ -252,6 +252,35 @@ class QueueClass<T> implements Queue<T> {
     }
   }
 
+  /**
+   * @internal
+   * Resizes the circular buffer when it becomes full.
+   * Doubles the capacity and reorganizes elements to maintain queue order.
+   */
+  #resize(): void {
+    const newCapacity = asUint32(this.#mut_capacity * 2);
+
+    const newBuffer = Array.from<unknown, T | undefined>(
+      { length: newCapacity },
+      () => undefined,
+    );
+
+    // Copy elements in order from head to tail
+    for (const i of range(asSafeUint(this.#mut_size))) {
+      const sourceIndex = (this.#mut_head + i) % this.#mut_capacity;
+
+      newBuffer[i] = this.#mut_buffer[sourceIndex];
+    }
+
+    this.#mut_buffer = newBuffer;
+
+    this.#mut_head = 0;
+
+    this.#mut_tail = this.#mut_size;
+
+    this.#mut_capacity = newCapacity;
+  }
+
   /** @inheritdoc */
   get isEmpty(): boolean {
     return this.#mut_size === 0;
@@ -322,35 +351,6 @@ class QueueClass<T> implements Queue<T> {
 
     this.#mut_size += 1;
   }
-
-  /**
-   * @internal
-   * Resizes the circular buffer when it becomes full.
-   * Doubles the capacity and reorganizes elements to maintain queue order.
-   */
-  #resize(): void {
-    const newCapacity = asUint32(this.#mut_capacity * 2);
-
-    const newBuffer = Array.from<unknown, T | undefined>(
-      { length: newCapacity },
-      () => undefined,
-    );
-
-    // Copy elements in order from head to tail
-    for (const i of range(asSafeUint(this.#mut_size))) {
-      const sourceIndex = (this.#mut_head + i) % this.#mut_capacity;
-
-      newBuffer[i] = this.#mut_buffer[sourceIndex];
-    }
-
-    this.#mut_buffer = newBuffer;
-
-    this.#mut_head = 0;
-
-    this.#mut_tail = this.#mut_size;
-
-    this.#mut_capacity = newCapacity;
-  }
 }
 
 /**

package/src/collections/stack.mts

@@ -200,6 +200,9 @@ export type Stack<T> = Readonly<{
  * @implements Stack
  */
 class StackClass<T> implements Stack<T> {
+  /** @internal Initial capacity for new stacks. */
+  static readonly #INITIAL_CAPACITY = 8;
+
   /** @internal Dynamic array to store stack elements. */
   #mut_buffer: (T | undefined)[];
 
@@ -209,9 +212,6 @@ class StackClass<T> implements Stack<T> {
   /** @internal Current capacity of the buffer. */
   #mut_capacity: Uint32;
 
-  /** @internal Initial capacity for new stacks. */
-  static readonly #INITIAL_CAPACITY = 8;
-
   /**
    * Constructs a new StackClass instance.
    *
@@ -237,6 +237,29 @@ class StackClass<T> implements Stack<T> {
     }
   }
 
+  /**
+   * @internal
+   * Resizes the buffer when it becomes full.
+   * Doubles the capacity while preserving all elements.
+   */
+  #resize(): void {
+    const newCapacity = asUint32(this.#mut_capacity * 2);
+
+    const newBuffer = Array.from<unknown, T | undefined>(
+      { length: newCapacity },
+      () => undefined,
+    );
+
+    // Copy existing elements
+    for (const i of range(this.#mut_size)) {
+      newBuffer[i] = this.#mut_buffer[i];
+    }
+
+    this.#mut_buffer = newBuffer;
+
+    this.#mut_capacity = newCapacity;
+  }
+
   /** @inheritdoc */
   get isEmpty(): boolean {
     return this.#mut_size === 0;
@@ -303,29 +326,6 @@ class StackClass<T> implements Stack<T> {
 
     this.#mut_size = Uint32.add(this.#mut_size, 1);
   }
-
-  /**
-   * @internal
-   * Resizes the buffer when it becomes full.
-   * Doubles the capacity while preserving all elements.
-   */
-  #resize(): void {
-    const newCapacity = asUint32(this.#mut_capacity * 2);
-
-    const newBuffer = Array.from<unknown, T | undefined>(
-      { length: newCapacity },
-      () => undefined,
-    );
-
-    // Copy existing elements
-    for (const i of range(this.#mut_size)) {
-      newBuffer[i] = this.#mut_buffer[i];
-    }
-
-    this.#mut_buffer = newBuffer;
-
-    this.#mut_capacity = newCapacity;
-  }
 }
 
 /**

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

@@ -13,9 +13,9 @@ import { type Unwrap } from './types.mjs';
  *
  * ```ts
  * const parseNumber = (input: string): Optional<number> => {
- *   const num = Number.parseInt(input, 10);
+ *   const num = Num.safeParseInt(input);
  *
- *   return Number.isNaN(num) ? Optional.none : Optional.some(num);
+ *   return Result.isErr(num) ? Optional.none : Optional.some(num.value);
  * };
  *
  * const parsed = Optional.flatMap(Optional.some('10'), parseNumber);

package/src/functional/optional.test.mts

@@ -1,7 +1,9 @@
 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 { pipe } from './pipe.mjs';
+import { Result } from './result/index.mjs';
 
 describe('Optional test', () => {
   describe('isOptional', () => {
@@ -374,7 +376,7 @@ describe('Optional test', () => {
   describe('flatMap', () => {
     test('should chain operations that return Optional', () => {
       const parseNumber = (s: string): Optional<number> => {
-        const n = Number(s);
+        const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
 
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
@@ -400,7 +402,7 @@ describe('Optional test', () => {
 
     test('should support chaining multiple flatMaps', () => {
       const parseNumber = (s: string): Optional<number> => {
-        const n = Number(s);
+        const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
 
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
@@ -424,7 +426,7 @@ describe('Optional test', () => {
 
     test('should support curried form', () => {
       const parseNumber = (s: string): Optional<number> => {
-        const n = Number(s);
+        const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
 
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
@@ -450,7 +452,7 @@ describe('Optional test', () => {
 
     test('should work with pipe when curried', () => {
       const parseNumber = (s: string): Optional<number> => {
-        const n = Number(s);
+        const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
 
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };

package/src/functional/pipe.mts

@@ -49,7 +49,6 @@ export const pipe = <const A,>(a: A): Pipe<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);

package/src/functional/pipe.test.mts

@@ -1,4 +1,5 @@
 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 { pipe } from './pipe.mjs';
@@ -89,7 +90,7 @@ describe(pipe, () => {
 
   test('chaining multiple operations', () => {
     const result = pipe('5')
-      .map((s) => Number.parseInt(s, 10))
+      .map((s) => Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN))
       .map((n) => n * 3)
       .map((n) => n.toString())
       .map((s) => `${s} items`).value;