ts-data-forge 5.0.1 → 5.1.1

package/src/functional/optional.test.mts

@@ -5,23 +5,31 @@ import { pipe } from './pipe.mjs';
 describe('Optional test', () => {
   describe('isOptional', () => {
     test('should return true for Some values', () => {
-      expect(Optional.isOptional(Optional.some(42))).toBe(true);
-      expect(Optional.isOptional(Optional.some('hello'))).toBe(true);
-      expect(Optional.isOptional(Optional.some(null))).toBe(true);
-      expect(Optional.isOptional(Optional.some(undefined))).toBe(true);
+      assert.isTrue(Optional.isOptional(Optional.some(42)));
+
+      assert.isTrue(Optional.isOptional(Optional.some('hello')));
+
+      assert.isTrue(Optional.isOptional(Optional.some(null)));
+
+      assert.isTrue(Optional.isOptional(Optional.some(undefined)));
     });
 
     test('should return true for None value', () => {
-      expect(Optional.isOptional(Optional.none)).toBe(true);
+      assert.isTrue(Optional.isOptional(Optional.none));
     });
 
     test('should return false for non-Optional values', () => {
-      expect(Optional.isOptional(42)).toBe(false);
-      expect(Optional.isOptional('hello')).toBe(false);
-      expect(Optional.isOptional(null)).toBe(false);
-      expect(Optional.isOptional(undefined)).toBe(false);
-      expect(Optional.isOptional({})).toBe(false);
-      expect(Optional.isOptional({ type: 'fake', value: 42 })).toBe(false);
+      assert.isFalse(Optional.isOptional(42));
+
+      assert.isFalse(Optional.isOptional('hello'));
+
+      assert.isFalse(Optional.isOptional(null));
+
+      assert.isFalse(Optional.isOptional(undefined));
+
+      assert.isFalse(Optional.isOptional({}));
+
+      assert.isFalse(Optional.isOptional({ type: 'fake', value: 42 }));
     });
   });
 
@@ -29,17 +37,19 @@ describe('Optional test', () => {
     test('should create a Some variant with the provided value', () => {
       const someNumber = Optional.some(42);
 
-      expect(Optional.isSome(someNumber)).toBe(true);
+      assert.isTrue(Optional.isSome(someNumber));
+
       expect(Optional.unwrap(someNumber)).toBe(42);
 
       const someString = Optional.some('hello');
 
-      expect(Optional.isSome(someString)).toBe(true);
+      assert.isTrue(Optional.isSome(someString));
+
       expect(Optional.unwrap(someString)).toBe('hello');
 
       const someObject = Optional.some({ name: 'Alice', age: 30 });
 
-      expect(Optional.isSome(someObject)).toBe(true);
+      assert.isTrue(Optional.isSome(someObject));
 
       assert.deepStrictEqual(Optional.unwrap(someObject), {
         name: 'Alice',
@@ -56,8 +66,10 @@ describe('Optional test', () => {
 
   describe('none', () => {
     test('should be a singleton None value', () => {
-      expect(Optional.isNone(Optional.none)).toBe(true);
-      expect(Optional.isSome(Optional.none)).toBe(false);
+      assert.isTrue(Optional.isNone(Optional.none));
+
+      assert.isFalse(Optional.isSome(Optional.none));
+
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
       expect(Optional.unwrapOr(Optional.none, undefined)).toBeUndefined();
     });
@@ -71,15 +83,17 @@ describe('Optional test', () => {
     test('should correctly identify Some values', () => {
       const some = Optional.some(42);
 
-      expect(Optional.isSome(some)).toBe(true);
-      expect(Optional.isNone(some)).toBe(false);
+      assert.isTrue(Optional.isSome(some));
+
+      assert.isFalse(Optional.isNone(some));
     });
 
     test('should correctly identify None values', () => {
       const none = Optional.none;
 
-      expect(Optional.isSome(none)).toBe(false);
-      expect(Optional.isNone(none)).toBe(true);
+      assert.isFalse(Optional.isSome(none));
+
+      assert.isTrue(Optional.isNone(none));
     });
 
     test('should act as type guards', () => {
@@ -98,9 +112,10 @@ describe('Optional test', () => {
   describe('map', () => {
     test('should map over Some values', () => {
       const some = Optional.some(5);
+
       const mapped = Optional.map(some, (x) => x * 2);
 
-      expect(Optional.isSome(mapped)).toBe(true);
+      assert.isTrue(Optional.isSome(mapped));
 
       if (Optional.isSome(mapped)) {
         expect(Optional.unwrap(mapped)).toBe(10);
@@ -109,9 +124,10 @@ describe('Optional test', () => {
 
     test('should return None for None values', () => {
       const none = Optional.none;
+
       const mapped = Optional.map(none, (x: never) => x * 2);
 
-      expect(Optional.isNone(mapped)).toBe(true);
+      assert.isTrue(Optional.isNone(mapped));
     });
 
     test('should support chaining', () => {
@@ -137,27 +153,30 @@ describe('Optional test', () => {
       const doubler = Optional.map((x: number) => x * 2);
 
       const some = Optional.some(5);
+
       const mapped = doubler(some);
 
-      expect(Optional.isSome(mapped)).toBe(true);
+      assert.isTrue(Optional.isSome(mapped));
 
       if (Optional.isSome(mapped)) {
         expect(Optional.unwrap(mapped)).toBe(10);
       }
 
       const none = Optional.none;
+
       const mappedNone = doubler(none);
 
-      expect(Optional.isNone(mappedNone)).toBe(true);
+      assert.isTrue(Optional.isNone(mappedNone));
     });
 
     test('should work with pipe when curried', () => {
       const doubler = Optional.map((x: number) => x * 2);
+
       const toStringFn = Optional.map((x: number) => x.toString());
 
       const result = pipe(Optional.some(5)).map(doubler).map(toStringFn).value;
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe('10');
@@ -168,7 +187,9 @@ describe('Optional test', () => {
   describe('unwrap', () => {
     test('should return the value for Some', () => {
       expect(Optional.unwrap(Optional.some(42))).toBe(42);
+
       expect(Optional.unwrap(Optional.some('hello'))).toBe('hello');
+
       expect(Optional.unwrap(Optional.some(null))).toBeNull();
     });
 
@@ -192,6 +213,7 @@ describe('Optional test', () => {
   describe('unwrapThrow', () => {
     test('should return the value for Some', () => {
       expect(Optional.unwrapThrow(Optional.some(42))).toBe(42);
+
       expect(Optional.unwrapThrow(Optional.some('hello'))).toBe('hello');
     });
 
@@ -211,6 +233,7 @@ describe('Optional test', () => {
   describe('unwrapOr', () => {
     test('should return the value for Some', () => {
       expect(Optional.unwrapOr(Optional.some(42), 0)).toBe(42);
+
       expect(Optional.unwrapOr(Optional.some('hello'), 'default')).toBe(
         'hello',
       );
@@ -218,6 +241,7 @@ describe('Optional test', () => {
 
     test('should return the default value for None', () => {
       expect(Optional.unwrapOr(Optional.none, 0)).toBe(0);
+
       expect(Optional.unwrapOr(Optional.none, 'default')).toBe('default');
     });
 
@@ -239,11 +263,13 @@ describe('Optional test', () => {
       const unwrapWithDefault = Optional.unwrapOr(42);
 
       const someValue = Optional.some(100);
+
       const result = unwrapWithDefault(someValue);
 
       expect(result).toBe(100);
 
       const noneValue = Optional.none;
+
       const defaultResult = unwrapWithDefault(noneValue);
 
       expect(defaultResult).toBe(42);
@@ -281,9 +307,11 @@ describe('Optional test', () => {
       const expectValidId = Optional.expectToBe<string>('ID is required');
 
       const id1 = Optional.some('user-123');
+
       const id2 = Optional.none;
 
       expect(expectValidId(id1)).toBe('user-123');
+
       expect(() => expectValidId(id2)).toThrow('ID is required');
     });
 
@@ -291,6 +319,7 @@ describe('Optional test', () => {
       const getValue = Optional.expectToBe('Value must exist');
 
       const someValue = Optional.some('important data');
+
       const result = getValue(someValue);
 
       expect(result).toBe('important data');
@@ -318,10 +347,13 @@ describe('Optional test', () => {
   describe('type utilities', () => {
     test('should correctly unwrap types', () => {
       type SomeNumber = Some<number>;
+
       type UnwrappedNumber = Optional.Unwrap<SomeNumber>;
+
       expectType<UnwrappedNumber, number>('=');
 
       type UnwrappedNone = Optional.Unwrap<None>;
+
       expectType<UnwrappedNone, never>('=');
     });
 
@@ -329,9 +361,11 @@ describe('Optional test', () => {
       type MaybeNumber = Optional<number>;
 
       type OnlySome = Optional.NarrowToSome<MaybeNumber>;
+
       expectType<OnlySome, Some<number>>('=');
 
       type OnlyNone = Optional.NarrowToNone<MaybeNumber>;
+
       expectType<OnlyNone, None>('=');
     });
   });
@@ -340,17 +374,19 @@ describe('Optional test', () => {
     test('should chain operations that return Optional', () => {
       const parseNumber = (s: string): Optional<number> => {
         const n = Number(s);
+
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
 
       const result = Optional.flatMap(Optional.some('42'), parseNumber);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(42);
       }
 
       const invalid = Optional.flatMap(Optional.some('abc'), parseNumber);
 
-      expect(Optional.isNone(invalid)).toBe(true);
+      assert.isTrue(Optional.isNone(invalid));
     });
 
     test('should return None if input is None', () => {
@@ -358,12 +394,13 @@ describe('Optional test', () => {
         Optional.some(42),
       );
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should support chaining multiple flatMaps', () => {
       const parseNumber = (s: string): Optional<number> => {
         const n = Number(s);
+
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
 
@@ -376,7 +413,9 @@ describe('Optional test', () => {
               Optional.some(n / divisor);
 
       const intermediate = Optional.flatMap(Optional.some('100'), parseNumber);
+
       const result = Optional.flatMap(intermediate, divideBy(2));
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(50);
       }
@@ -385,6 +424,7 @@ describe('Optional test', () => {
     test('should support curried form', () => {
       const parseNumber = (s: string): Optional<number> => {
         const n = Number(s);
+
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
 
@@ -392,7 +432,7 @@ describe('Optional test', () => {
 
       const result = parser(Optional.some('42'));
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(42);
@@ -400,16 +440,17 @@ describe('Optional test', () => {
 
       const invalid = parser(Optional.some('abc'));
 
-      expect(Optional.isNone(invalid)).toBe(true);
+      assert.isTrue(Optional.isNone(invalid));
 
       const noneResult = parser(Optional.none);
 
-      expect(Optional.isNone(noneResult)).toBe(true);
+      assert.isTrue(Optional.isNone(noneResult));
     });
 
     test('should work with pipe when curried', () => {
       const parseNumber = (s: string): Optional<number> => {
         const n = Number(s);
+
         return Number.isNaN(n) ? Optional.none : Optional.some(n);
       };
 
@@ -417,11 +458,12 @@ describe('Optional test', () => {
         n > 0 ? Optional.some(n * 2) : Optional.none;
 
       const parser = Optional.flatMap(parseNumber);
+
       const doubler = Optional.flatMap(doubleIfPositive);
 
       const result = pipe(Optional.some('42')).map(parser).map(doubler).value;
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(84);
@@ -432,7 +474,9 @@ describe('Optional test', () => {
   describe('filter', () => {
     test('should keep Some values that match predicate', () => {
       const someEven = Optional.some(4);
+
       const filtered = Optional.filter(someEven, (x) => x % 2 === 0);
+
       if (Optional.isSome(filtered)) {
         expect(Optional.unwrap(filtered)).toBe(4);
       }
@@ -440,48 +484,52 @@ describe('Optional test', () => {
 
     test('should return None for Some values that do not match predicate', () => {
       const someOdd = Optional.some(5);
+
       const filtered = Optional.filter(someOdd, (x) => x % 2 === 0);
 
-      expect(Optional.isNone(filtered)).toBe(true);
+      assert.isTrue(Optional.isNone(filtered));
     });
 
     test('should return None if input is None', () => {
       const filtered = Optional.filter(Optional.none, (_: never) => true);
 
-      expect(Optional.isNone(filtered)).toBe(true);
+      assert.isTrue(Optional.isNone(filtered));
     });
 
     test('should support curried form', () => {
       const evenFilter = Optional.filter((x: number) => x % 2 === 0);
 
       const someEven = Optional.some(4);
+
       const filtered = evenFilter(someEven);
 
-      expect(Optional.isSome(filtered)).toBe(true);
+      assert.isTrue(Optional.isSome(filtered));
 
       if (Optional.isSome(filtered)) {
         expect(Optional.unwrap(filtered)).toBe(4);
       }
 
       const someOdd = Optional.some(5);
+
       const filteredOdd = evenFilter(someOdd);
 
-      expect(Optional.isNone(filteredOdd)).toBe(true);
+      assert.isTrue(Optional.isNone(filteredOdd));
 
       const noneResult = evenFilter(Optional.none);
 
-      expect(Optional.isNone(noneResult)).toBe(true);
+      assert.isTrue(Optional.isNone(noneResult));
     });
 
     test('should work with pipe when curried', () => {
       const evenFilter = Optional.filter((x: number) => x % 2 === 0);
+
       const positiveFilter = Optional.filter((x: number) => x > 0);
 
       const result = pipe(Optional.some(4))
         .map(evenFilter)
         .map(positiveFilter).value;
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(4);
@@ -489,15 +537,18 @@ describe('Optional test', () => {
 
       const filtered = pipe(Optional.some(3)).map(evenFilter).value;
 
-      expect(Optional.isNone(filtered)).toBe(true);
+      assert.isTrue(Optional.isNone(filtered));
     });
   });
 
   describe('orElse', () => {
     test('should return the first Optional if it is Some', () => {
       const primary = Optional.some(42);
+
       const fallback = Optional.some(100);
+
       const result = Optional.orElse(primary, fallback);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe(42);
       }
@@ -505,8 +556,11 @@ describe('Optional test', () => {
 
     test('should return the alternative if the first is None', () => {
       const primary = Optional.none;
+
       const fallback = Optional.some('default');
+
       const result = Optional.orElse(primary, fallback);
+
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe('default');
       }
@@ -515,25 +569,27 @@ describe('Optional test', () => {
     test('should return None if both are None', () => {
       const result = Optional.orElse(Optional.none, Optional.none);
 
-      expect(Optional.isNone(result)).toBe(true);
+      assert.isTrue(Optional.isNone(result));
     });
 
     test('should support curried form', () => {
       const fallbackTo = Optional.orElse(Optional.some('fallback'));
 
       const someValue = Optional.some('primary');
+
       const result = fallbackTo(someValue);
 
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(Optional.unwrap(result)).toBe('primary');
       }
 
       const noneValue = Optional.none;
+
       const fallbackResult = fallbackTo(noneValue);
 
-      expect(Optional.isSome(fallbackResult)).toBe(true);
+      assert.isTrue(Optional.isSome(fallbackResult));
 
       if (Optional.isSome(fallbackResult)) {
         expect(Optional.unwrap(fallbackResult)).toBe('fallback');
@@ -545,7 +601,7 @@ describe('Optional test', () => {
 
       const someResult = pipe(Optional.some('original')).map(fallbackTo).value;
 
-      expect(Optional.isSome(someResult)).toBe(true);
+      assert.isTrue(Optional.isSome(someResult));
 
       if (Optional.isSome(someResult)) {
         expect(Optional.unwrap(someResult)).toBe('original');
@@ -553,7 +609,7 @@ describe('Optional test', () => {
 
       const noneResult = pipe(Optional.none).map(fallbackTo).value;
 
-      expect(Optional.isSome(noneResult)).toBe(true);
+      assert.isTrue(Optional.isSome(noneResult));
 
       if (Optional.isSome(noneResult)) {
         expect(Optional.unwrap(noneResult)).toBe('backup');
@@ -564,8 +620,11 @@ describe('Optional test', () => {
   describe('zip', () => {
     test('should combine two Some values into a tuple', () => {
       const a = Optional.some(1);
+
       const b = Optional.some('hello');
+
       const zipped = Optional.zip(a, b);
+
       if (Optional.isSome(zipped)) {
         assert.deepStrictEqual(Optional.unwrap(zipped), [1, 'hello']);
       }
@@ -573,53 +632,61 @@ describe('Optional test', () => {
 
     test('should return None if first is None', () => {
       const a = Optional.none;
+
       const b = Optional.some('hello');
+
       const zipped = Optional.zip(a, b);
 
-      expect(Optional.isNone(zipped)).toBe(true);
+      assert.isTrue(Optional.isNone(zipped));
     });
 
     test('should return None if second is None', () => {
       const a = Optional.some(1);
+
       const b = Optional.none;
+
       const zipped = Optional.zip(a, b);
 
-      expect(Optional.isNone(zipped)).toBe(true);
+      assert.isTrue(Optional.isNone(zipped));
     });
 
     test('should return None if both are None', () => {
       const zipped = Optional.zip(Optional.none, Optional.none);
 
-      expect(Optional.isNone(zipped)).toBe(true);
+      assert.isTrue(Optional.isNone(zipped));
     });
   });
 
   describe('fromNullable', () => {
     test('should convert non-null values to Some', () => {
       const helloOpt = Optional.fromNullable('hello');
+
       if (Optional.isSome(helloOpt))
         expect(Optional.unwrap(helloOpt)).toBe('hello');
 
       const numOpt = Optional.fromNullable(42);
+
       if (Optional.isSome(numOpt)) expect(Optional.unwrap(numOpt)).toBe(42);
 
       const zeroOpt = Optional.fromNullable(0);
+
       if (Optional.isSome(zeroOpt)) expect(Optional.unwrap(zeroOpt)).toBe(0);
 
       const emptyOpt = Optional.fromNullable('');
+
       if (Optional.isSome(emptyOpt)) expect(Optional.unwrap(emptyOpt)).toBe('');
 
       const falseOpt = Optional.fromNullable(false);
-      if (Optional.isSome(falseOpt))
-        expect(Optional.unwrap(falseOpt)).toBe(false);
+
+      if (Optional.isSome(falseOpt)) assert.isFalse(Optional.unwrap(falseOpt));
     });
 
     test('should convert null to None', () => {
-      expect(Optional.isNone(Optional.fromNullable(null))).toBe(true);
+      assert.isTrue(Optional.isNone(Optional.fromNullable(null)));
     });
 
     test('should convert undefined to None', () => {
-      expect(Optional.isNone(Optional.fromNullable(undefined))).toBe(true);
+      assert.isTrue(Optional.isNone(Optional.fromNullable(undefined)));
     });
 
     test('should work with union types', () => {
@@ -632,7 +699,9 @@ describe('Optional test', () => {
   describe('toNullable', () => {
     test('should convert Some to its value', () => {
       expect(Optional.toNullable(Optional.some(42))).toBe(42);
+
       expect(Optional.toNullable(Optional.some('hello'))).toBe('hello');
+
       expect(Optional.toNullable(Optional.some(null))).toBeNull();
     });
 
@@ -652,7 +721,8 @@ describe('Optional test', () => {
     test('should handle undefined as a Some value', () => {
       const someUndefined = Optional.some(undefined);
 
-      expect(Optional.isSome(someUndefined)).toBe(true);
+      assert.isTrue(Optional.isSome(someUndefined));
+
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
       expect(Optional.unwrap(someUndefined)).toBeUndefined();
 
@@ -663,18 +733,20 @@ describe('Optional test', () => {
     test('should handle null as a Some value', () => {
       const someNull = Optional.some(null);
 
-      expect(Optional.isSome(someNull)).toBe(true);
+      assert.isTrue(Optional.isSome(someNull));
+
       expect(Optional.unwrap(someNull)).toBeNull();
     });
 
     test('should handle nested Optionals', () => {
       const nested = Optional.some(Optional.some(42));
 
-      expect(Optional.isSome(nested)).toBe(true);
+      assert.isTrue(Optional.isSome(nested));
 
       const inner = Optional.unwrap(nested);
 
-      expect(Optional.isOptional(inner)).toBe(true);
+      assert.isTrue(Optional.isOptional(inner));
+
       expect(Optional.unwrap(inner)).toBe(42);
     });
   });

package/src/functional/pipe.mts

@@ -89,7 +89,7 @@ type PipeBase<A> = Readonly<{
    *   value.toUpperCase(),
    * );
    *
-   * assert(empty.value === undefined);
+   * assert.isTrue(empty.value === undefined);
    * ```
    *
    * @template B The type of the transformed value.
@@ -127,7 +127,7 @@ type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<
        *   (value) => value * 2,
        * );
        *
-       * assert.ok(Optional.isNone(empty.value));
+       * assert.isTrue(Optional.isNone(empty.value));
        * ```
        *
        * @template B The type of the transformed inner value.

package/src/functional/pipe.test.mts

@@ -61,23 +61,26 @@ describe(pipe, () => {
 
   test('mapOptional with Some value', () => {
     const optional = Optional.some(42);
+
     const result = pipe(optional).mapOptional((x) => x * 2).value;
 
-    expect(Optional.isSome(result)).toBe(true);
+    assert.isTrue(Optional.isSome(result));
 
     if (Optional.isSome(result)) {
       expect(result.value).toBe(84);
     }
-    expectType<typeof result, Optional<number>>('=');
+
+    expectType<typeof result, Some<number>>('=');
   });
 
   test('mapOptional with None value', () => {
     const optional: Optional<number> = Optional.none;
+
     const result = pipe(optional).mapOptional((x) => x * 2).value;
 
-    expect(Optional.isNone(result)).toBe(true);
+    assert.isTrue(Optional.isNone(result));
 
-    expectType<typeof result, Optional<number>>('=');
+    expectType<typeof result, None>('=');
   });
 
   test('chaining multiple operations', () => {

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

@@ -10,20 +10,22 @@ import { ErrTypeTagName } from './tag.mjs';
  *
  * ```ts
  * const success = Result.ok({ id: 1 });
+ *
  * const failure = Result.err(new Error('missing data'));
  *
  * assert.deepStrictEqual(success, {
  *   $$tag: 'ts-data-forge::Result.ok',
  *   value: { id: 1 },
  * });
- * assert.ok(Result.isErr(failure));
+ *
+ * assert.isTrue(Result.isErr(failure));
  * ```
  *
  * @template E The type of the error value.
  * @param value The error value.
  * @returns A `Result.Err<E>` containing the value.
  */
-export const err = <E,>(value: E): Err<E> => ({
+export const err = <const E,>(value: E): Err<E> => ({
   $$tag: ErrTypeTagName,
   value,
 });