ts-data-forge 5.0.1 → 5.1.1

package/src/array/impl/array-utils-modification.test.mts

@@ -14,6 +14,7 @@ import {
 describe('Arr modifications', () => {
   describe(toUpdated, () => {
     const xs = [1, 2, 3] as const;
+
     const result = toUpdated(xs, 1, (x) => x + 2);
 
     expectType<typeof result, ArrayOfLength<3, number>>('=');
@@ -21,6 +22,14 @@ describe('Arr modifications', () => {
     test('case 1', () => {
       assert.deepStrictEqual(result, [1, 4, 3]);
     });
+
+    test('should work with curried version', () => {
+      const updater = toUpdated(1, (x: number) => x * 2);
+
+      const r = updater([10, 20, 30]);
+
+      assert.deepStrictEqual(r, [10, 40, 30]);
+    });
   });
 
   describe(toInserted, () => {
@@ -53,11 +62,20 @@ describe('Arr modifications', () => {
 
       assert.deepStrictEqual(result, ['a', 'b', 'c', 5]);
     });
+
+    test('should work with curried version', () => {
+      const inserter = toInserted(2, 99);
+
+      const result = inserter([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 99, 3]);
+    });
   });
 
   describe(toRemoved, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toRemoved(xs, 1);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
@@ -67,6 +85,7 @@ describe('Arr modifications', () => {
 
     test('case 2 (remove head)', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toRemoved(xs, 0);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
@@ -76,6 +95,7 @@ describe('Arr modifications', () => {
 
     test('case 3 (remove tail)', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toRemoved(xs, 2);
 
       expectType<typeof result, readonly (1 | 2 | 3)[]>('=');
@@ -85,17 +105,27 @@ describe('Arr modifications', () => {
 
     test('case 4 (number[])', () => {
       const xs: number[] = [1, 2, 3];
+
       const result = toRemoved(xs, 5);
 
       expectType<typeof result, readonly number[]>('=');
 
       assert.deepStrictEqual(result, [1, 2, 3]);
     });
+
+    test('should work with curried version', () => {
+      const removeFirst = toRemoved(0);
+
+      const result = removeFirst([10, 20, 30]);
+
+      assert.deepStrictEqual(result, [20, 30]);
+    });
   });
 
   describe(toPushed, () => {
     test('case 1', () => {
       const xs = [1, 2, 3] as const;
+
       const result = toPushed(xs, 4 as const);
 
       expectType<typeof result, readonly [1, 2, 3, 4]>('=');
@@ -105,12 +135,21 @@ describe('Arr modifications', () => {
 
     test('case 2', () => {
       const xs: number[] = [1, 2, 3];
+
       const result = toPushed(xs, 4 as const);
 
       expectType<typeof result, readonly [...number[], 4]>('=');
 
       assert.deepStrictEqual(result, [1, 2, 3, 4]);
     });
+
+    test('should work with curried version', () => {
+      const pushFive = toPushed(5);
+
+      const result = pushFive([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [1, 2, 3, 5]);
+    });
   });
 
   describe(toUnshifted, () => {
@@ -133,11 +172,20 @@ describe('Arr modifications', () => {
 
       assert.deepStrictEqual(result, [4, 1, 2, 3]);
     });
+
+    test('should work with curried version', () => {
+      const unshiftZero = toUnshifted(0);
+
+      const result = unshiftZero([1, 2, 3]);
+
+      assert.deepStrictEqual(result, [0, 1, 2, 3]);
+    });
   });
 
   describe(toFilled, () => {
     test('should fill entire array with value', () => {
       const arr = [1, 2, 3, 4, 5];
+
       const result = toFilled(arr, 0);
 
       assert.deepStrictEqual(result, [0, 0, 0, 0, 0]);
@@ -145,7 +193,9 @@ describe('Arr modifications', () => {
 
     test('should work with curried version', () => {
       const fillWithZero = toFilled(0);
+
       const arr = [1, 2, 3];
+
       const result = fillWithZero(arr);
 
       assert.deepStrictEqual(result, [0, 0, 0]);
@@ -155,6 +205,7 @@ describe('Arr modifications', () => {
   describe(toRangeFilled, () => {
     test('should fill array with range', () => {
       const arr = [1, 2, 3, 4, 5];
+
       const result = toRangeFilled(arr, 0, [1, 4]);
 
       assert.deepStrictEqual(result, [1, 0, 0, 0, 5]);
@@ -162,6 +213,7 @@ describe('Arr modifications', () => {
 
     test('should fill with range starting from 0', () => {
       const arr = [1, 2, 3, 4, 5];
+
       const result = toRangeFilled(arr, 9, [0, 3]);
 
       assert.deepStrictEqual(result, [9, 9, 9, 4, 5]);
@@ -169,6 +221,7 @@ describe('Arr modifications', () => {
 
     test('should handle empty range', () => {
       const arr = [1, 2, 3];
+
       const result = toRangeFilled(arr, 0, [2, 2]);
 
       assert.deepStrictEqual(result, [1, 2, 3]);
@@ -176,6 +229,7 @@ describe('Arr modifications', () => {
 
     test('should clamp range to array bounds', () => {
       const arr = [1, 2, 3];
+
       const result = toRangeFilled(arr, 0, [1, 10]);
 
       assert.deepStrictEqual(result, [1, 0, 0]);
@@ -183,11 +237,20 @@ describe('Arr modifications', () => {
 
     test('should handle negative start (clamped to 0)', () => {
       const arr = [1, 2, 3];
+
       const result = toRangeFilled(arr, 9, [-5, 2]);
 
       assert.deepStrictEqual(result, [9, 9, 3]);
     });
 
+    test('should work with curried version', () => {
+      const fillMiddle = toRangeFilled(7, [1, 3]);
+
+      const result = fillMiddle([1, 2, 3, 4]);
+
+      assert.deepStrictEqual(result, [1, 7, 7, 4]);
+    });
+
     test('A non-integer starting value should result in a type error', () => {
       const arr = [1, 2, 3];
 
@@ -214,7 +277,9 @@ describe('Arr modifications', () => {
 
     test('should work with different value types', () => {
       const nums = [1, 2, 3] as const;
+
       const withString = set(nums, 1, 'two');
+
       expectType<typeof withString, readonly [1 | 'two', 2 | 'two', 3 | 'two']>(
         '=',
       );
@@ -224,6 +289,7 @@ describe('Arr modifications', () => {
 
     test('should work at index 0', () => {
       const tuple = ['a', 'b', 'c'] as const;
+
       const updated = set(tuple, 0, 'A');
 
       assert.deepStrictEqual(updated, ['A', 'b', 'c']);
@@ -231,9 +297,18 @@ describe('Arr modifications', () => {
 
     test('should work at last index', () => {
       const tuple = ['a', 'b', 'c'] as const;
+
       const updated = set(tuple, 2, 'C');
 
       assert.deepStrictEqual(updated, ['a', 'b', 'C']);
     });
+
+    test('should work with curried version', () => {
+      const setIndex1To99 = set(1, 99);
+
+      const r = setIndex1To99([10, 20, 30]);
+
+      assert.deepStrictEqual(r, [10, 99, 30]);
+    });
   });
 });

package/src/array/impl/array-utils-overload-type-error.test.mts

@@ -8,20 +8,25 @@ import { filterNot, partition } from './array-utils-transformation.mjs';
 
 describe('Array overloaded functions - type error validation', () => {
   const testArray = [1, 2, 3, 4, 5] as const;
+
   const predicate = (x: number): boolean => x > 3;
 
   describe('findIndex type safety', () => {
     test('findIndex with correct arguments should work', () => {
       // These should work fine
       const _result1 = findIndex(testArray, predicate);
+
       const _result2 = findIndex(predicate);
+
       const _result3 = findIndex(predicate)(testArray);
 
       expectType<typeof _result1, 0 | 1 | 2 | 3 | 4 | -1>('=');
+
       expectType<
         typeof _result2,
         (array: readonly number[]) => SizeType.Arr | -1
       >('=');
+
       expectType<typeof _result3, SizeType.Arr | -1>('=');
     });
 
@@ -41,14 +46,18 @@ describe('Array overloaded functions - type error validation', () => {
     test('filterNot with correct arguments should work', () => {
       // These should work fine
       const _result1 = filterNot(testArray, predicate);
+
       const _result2 = filterNot(predicate);
+
       const _result3 = filterNot(predicate)(testArray);
 
       expectType<typeof _result1, readonly number[]>('<=');
+
       expectType<
         typeof _result2,
         (array: readonly number[]) => readonly number[]
       >('<=');
+
       expectType<typeof _result3, readonly number[]>('<=');
     });
 
@@ -67,14 +76,18 @@ describe('Array overloaded functions - type error validation', () => {
     test('partition with correct arguments should work', () => {
       // These should work fine
       const _result1 = partition(testArray, 2);
+
       const _result2 = partition(2);
+
       const _result3 = partition(2)(testArray);
 
       expectType<typeof _result1, readonly (readonly number[])[]>('<=');
+
       expectType<
         typeof _result2,
         <A>(array: readonly A[]) => readonly (readonly A[])[]
       >('<=');
+
       expectType<typeof _result3, readonly (readonly number[])[]>('<=');
     });
 
@@ -93,9 +106,11 @@ describe('Array overloaded functions - type error validation', () => {
     test('range with correct arguments should work', () => {
       // These should work fine
       const _result1 = range(1, 5);
+
       const _result2 = range(1, 5, 1);
 
       expectType<typeof _result1, readonly [1, 2, 3, 4]>('=');
+
       expectType<typeof _result2, readonly [1, 2, 3, 4]>('=');
     });
 
@@ -112,12 +127,15 @@ describe('Array overloaded functions - type error validation', () => {
     test('spread with correct tuple types should work', () => {
       // Correct usage with spread
       const correctArgs1 = [testArray, predicate] as const;
+
       const correctArgs2 = [predicate] as const;
 
       const _result1 = findIndex(...correctArgs1);
+
       const _result2 = findIndex(...correctArgs2);
 
       expectType<typeof _result1, 0 | 1 | 2 | 3 | 4 | -1>('<=');
+
       expectType<
         typeof _result2,
         (array: readonly number[]) => SizeType.Arr | -1
@@ -141,6 +159,7 @@ describe('Array overloaded functions - type error validation', () => {
     test('composition should preserve type safety', () => {
       // This should work
       const findPositive = findIndex((x: number) => x > 0);
+
       const filterNegative = filterNot((x: number) => x < 0);
 
       const _composedResult = pipe(testArray)

package/src/array/impl/array-utils-reducing-value.mts

@@ -13,14 +13,19 @@ import { isNonEmpty } from './array-utils-validation.mjs';
  *
  * ```ts
  * const values = [5, 3, 9] as const;
+ *
  * const empty: readonly number[] = [];
  *
  * const smallest = Arr.min(values);
+ *
  * const none = Arr.min(empty);
+ *
  * const custom = Arr.min(values, (a, b) => b - a);
  *
  * assert.deepStrictEqual(smallest, Optional.some(3));
+ *
  * assert.deepStrictEqual(none, Optional.none);
+ *
  * assert.deepStrictEqual(custom, Optional.some(9));
  * ```
  */
@@ -62,9 +67,11 @@ export function min<E extends number>(
  * const values = [5, 3, 9];
  *
  * const largest = Arr.max(values);
+ *
  * const reversed = Arr.max(values, (a, b) => b - a);
  *
  * assert.deepStrictEqual(largest, Optional.some(9));
+ *
  * assert.deepStrictEqual(reversed, Optional.some(3));
  * ```
  */
@@ -84,6 +91,7 @@ export function max<E extends number>(
   comparator?: (x: E, y: E) => number,
 ): Optional<E> {
   const cmp = comparator ?? ((x, y) => Num.from(x) - Num.from(y));
+
   // Find max by finding min with an inverted comparator
   return min(array, (x, y) => -cmp(x, y));
 }
@@ -101,6 +109,7 @@ export function max<E extends number>(
  * ] as const;
  *
  * const leastVisits = Arr.minBy(users, (user) => user.visits);
+ *
  * const custom = Arr.minBy(
  *   users,
  *   (user) => user.visits,
@@ -108,6 +117,7 @@ export function max<E extends number>(
  * );
  *
  * assert.deepStrictEqual(leastVisits, Optional.some({ id: 2, visits: 3 }));
+ *
  * assert.deepStrictEqual(custom, Optional.some({ id: 1, visits: 10 }));
  * ```
  */
@@ -148,6 +158,7 @@ export function minBy<E, V>(
  * ];
  *
  * const mostStars = Arr.maxBy(projects, (project) => project.stars);
+ *
  * const smallestStars = Arr.maxBy(
  *   projects,
  *   (project) => project.stars,
@@ -155,6 +166,7 @@ export function minBy<E, V>(
  * );
  *
  * assert.deepStrictEqual(mostStars, Optional.some({ id: 'b', stars: 30 }));
+ *
  * assert.deepStrictEqual(smallestStars, Optional.some({ id: 'a', stars: 10 }));
  * ```
  */
@@ -191,10 +203,12 @@ export function maxBy<E, V>(
  * const words = ['Ada', 'Grace', 'Linus'] as const;
  *
  * const longWords = Arr.count(words, (word) => word.length > 4);
+ *
  * const withCurried = Arr.count<string>((word) => word.includes('a'))(words);
  *
- * assert(longWords === 2);
- * assert(withCurried === 2);
+ * assert.isTrue(longWords === 2);
+ *
+ * assert.isTrue(withCurried === 2);
  * ```
  */
 export function count<const Ar extends readonly unknown[]>(
@@ -217,14 +231,17 @@ export function count<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       return array.reduce<Uint32>(
         (acc, curr, index) =>
           predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
         asUint32(0),
       );
     }
+
     case 1: {
       const [predicate] = args;
+
       return (array) => count(array, predicate);
     }
   }
@@ -241,7 +258,9 @@ export function count<E>(
  * const counts = Arr.countBy(words, (word) => word[0]);
  *
  * assert.deepStrictEqual(counts.get('A'), Optional.some(2));
+ *
  * assert.deepStrictEqual(counts.get('G'), Optional.some(1));
+ *
  * assert.deepStrictEqual(counts.get('B'), Optional.some(1));
  * ```
  */
@@ -268,10 +287,12 @@ export function countBy<E, G extends MapSetKeyType>(
   switch (args.length) {
     case 2: {
       const [array, grouper] = args;
+
       const mut_groups = new Map<G, SizeType.Arr>();
 
       for (const [index, e] of array.entries()) {
         const key = grouper(e, asUint32(index));
+
         const curr = mut_groups.get(key) ?? 0;
 
         mut_groups.set(key, asUint32(curr + 1));
@@ -279,8 +300,10 @@ export function countBy<E, G extends MapSetKeyType>(
 
       return IMap.create(mut_groups);
     }
+
     case 1: {
       const [grouper] = args;
+
       return (array) => countBy(array, grouper);
     }
   }
@@ -295,13 +318,15 @@ export function countBy<E, G extends MapSetKeyType>(
  * const words = ['Ada', 'Lovelace'];
  *
  * const totalLength = Arr.foldl(words, (acc, word) => acc + word.length, 0);
+ *
  * const concat = Arr.foldl<string | number, string>(
  *   (acc, value) => `${acc}-${value}`,
  *   'items',
  * )(words);
  *
- * assert(totalLength === 11);
- * assert(concat === 'items-Ada-Lovelace');
+ * assert.isTrue(totalLength === 11);
+ *
+ * assert.isTrue(concat === 'items-Ada-Lovelace');
  * ```
  */
 export function foldl<const Ar extends readonly unknown[], P>(
@@ -346,13 +371,16 @@ export function foldl<E, P>(
   switch (args.length) {
     case 3: {
       const [array, callbackfn, initialValue] = args;
+
       return array.reduce(
         (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
         initialValue,
       );
     }
+
     case 2: {
       const [callbackfn, initialValue] = args;
+
       return (array) => foldl(array, callbackfn, initialValue);
     }
   }
@@ -367,13 +395,15 @@ export function foldl<E, P>(
  * const numbers = [1, 2, 3];
  *
  * const subtractRight = Arr.foldr(numbers, (acc, value) => acc - value, 0);
+ *
  * const joinFromRight = Arr.foldr<number, string>(
  *   (acc, value) => `${acc}${value}`,
  *   '',
  * )(numbers);
  *
- * assert(subtractRight === -6);
- * assert(joinFromRight === '321');
+ * assert.isTrue(subtractRight === -6);
+ *
+ * assert.isTrue(joinFromRight === '321');
  * ```
  */
 export function foldr<const Ar extends readonly unknown[], P>(
@@ -418,13 +448,16 @@ export function foldr<E, P>(
   switch (args.length) {
     case 3: {
       const [array, callbackfn, initialValue] = args;
+
       return array.reduceRight(
         (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
         initialValue,
       );
     }
+
     case 2: {
       const [callbackfn, initialValue] = args;
+
       return (array) => foldr(array, callbackfn, initialValue);
     }
   }
@@ -437,13 +470,16 @@ export function foldr<E, P>(
  *
  * ```ts
  * const numbers = [1, 2, 3, 4] as const;
+ *
  * const negatives = [3, -2, 5] as const;
  *
  * const total = Arr.sum(numbers);
+ *
  * const totalNegatives = Arr.sum(negatives);
  *
- * assert(total === 10);
- * assert(totalNegatives === 6);
+ * assert.isTrue(total === 10);
+ *
+ * assert.isTrue(totalNegatives === 6);
  * ```
  */
 export function sum(array: readonly []): 0;
@@ -469,50 +505,59 @@ export function sum(array: readonly number[]): number {
  * const numbers = [1, 2, 3] as const;
  *
  * const defaultSeparator = Arr.join(numbers);
+ *
  * const hyphenSeparated = Arr.join(numbers, '-');
  *
  * assert.deepStrictEqual(defaultSeparator, Result.ok('1,2,3'));
+ *
  * assert.deepStrictEqual(hyphenSeparated, Result.ok('1-2-3'));
  * ```
  */
-export function join<E>(
-  array: readonly E[],
+export function join(
+  array: readonly unknown[],
   separator?: string,
 ): Result<string, Error>;
 
 export function join(
   separator?: string,
-): <E>(array: readonly E[]) => Result<string, Error>;
+): (array: readonly unknown[]) => Result<string, Error>;
 
-export function join<E>(
+export function join(
   ...args:
-    | readonly [array: readonly E[], separator?: string]
+    | readonly [array: readonly unknown[], separator?: string]
     | readonly [separator?: string]
-): Result<string, Error> | ((array: readonly E[]) => Result<string, Error>) {
+):
+  | Result<string, Error>
+  | ((array: readonly unknown[]) => Result<string, Error>) {
   switch (args.length) {
     case 0:
       return (array) => joinImpl(array, undefined);
 
     case 1: {
       const [arg] = args;
+
       if (isString(arg) || isUndefined(arg)) {
         return (array) => joinImpl(array, arg);
       }
+
       return joinImpl(arg, undefined);
     }
+
     case 2: {
       const [array, separator] = args;
+
       return joinImpl(array, separator);
     }
   }
 }
 
-const joinImpl = <E,>(
-  array: readonly E[],
+const joinImpl = (
+  array: readonly unknown[],
   separator: string | undefined,
 ): Result<string, Error> => {
   try {
     const result = array.join(separator);
+
     return Result.ok(result);
   } catch (error) {
     return Result.err(