ts-data-forge 5.0.1 → 5.1.0

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,9 +203,11 @@ 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);
  * ```
  */
@@ -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,12 +318,14 @@ 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');
  * ```
  */
@@ -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,12 +395,14 @@ 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');
  * ```
  */
@@ -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,12 +470,15 @@ 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);
  * ```
  */
@@ -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(

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

@@ -18,6 +18,7 @@ describe('Arr reducing value', () => {
   describe(min, () => {
     {
       const xs = [3, 5, 4] as const;
+
       const result = min(xs);
 
       expectType<typeof result, Some<3 | 4 | 5>>('=');
@@ -30,8 +31,10 @@ describe('Arr reducing value', () => {
         }
       });
     }
+
     {
       const xs = [3, 5, 4] as const;
+
       const result = min(xs, (a, b) => a - b);
 
       expectType<typeof result, Some<3 | 4 | 5>>('=');
@@ -44,8 +47,10 @@ describe('Arr reducing value', () => {
         }
       });
     }
+
     {
       const xs: readonly (3 | 4 | 5)[] = [3, 5, 4] as const;
+
       const result = min(xs, (a, b) => a - b);
 
       expectType<typeof result, Optional<3 | 4 | 5>>('=');
@@ -62,6 +67,7 @@ describe('Arr reducing value', () => {
 
   describe(max, () => {
     const xs = [3, 5, 4] as const;
+
     const result = max(xs, (a, b) => a - b);
 
     expectType<typeof result, Some<3 | 4 | 5>>('=');
@@ -76,6 +82,7 @@ describe('Arr reducing value', () => {
 
     test('case 2: no comparator', () => {
       const res = max(xs);
+
       expectType<typeof res, Some<3 | 4 | 5>>('=');
 
       expect(Optional.isSome(res)).toBe(true);
@@ -87,7 +94,9 @@ describe('Arr reducing value', () => {
 
     test('case 3: readonly array', () => {
       const arr: readonly number[] = [1, 5, 2];
+
       const res = max(arr);
+
       expectType<typeof res, Optional<number>>('=');
 
       expect(Optional.isSome(res)).toBe(true);
@@ -99,7 +108,9 @@ describe('Arr reducing value', () => {
 
     test('case 4: empty array', () => {
       const arr: readonly number[] = [];
+
       const res = max(arr);
+
       expectType<typeof res, Optional<number>>('=');
 
       expect(Optional.isNone(res)).toBe(true);
@@ -142,7 +153,9 @@ describe('Arr reducing value', () => {
 
     test('case 2: empty array', () => {
       const arr: readonly { x: number }[] = [];
+
       const res = minBy(arr, (a) => a.x);
+
       expectType<typeof res, Optional<{ x: number }>>('=');
 
       expect(Optional.isNone(res)).toBe(true);
@@ -216,7 +229,9 @@ describe('Arr reducing value', () => {
 
     test('case 2: empty array', () => {
       const arr: readonly { x: number }[] = [];
+
       const res = maxBy(arr, (a) => a.x);
+
       expectType<typeof res, Optional<{ x: number }>>('=');
 
       expect(Optional.isNone(res)).toBe(true);
@@ -274,11 +289,21 @@ describe('Arr reducing value', () => {
 
     test('case 2: empty array', () => {
       const arr: readonly number[] = [];
+
       const res = count(arr, (x) => x > 0);
+
       expectType<typeof res, Uint32>('=');
 
       expect(res).toBe(0);
     });
+
+    test('should work with curried version', () => {
+      const countEven = count((x: number) => x % 2 === 0);
+
+      const res = countEven([1, 2, 3, 4, 5, 6]);
+
+      expect(res).toBe(3);
+    });
   });
 
   describe(countBy, () => {
@@ -308,16 +333,41 @@ describe('Arr reducing value', () => {
 
     test('case 2: empty array', () => {
       const arr: readonly { x: number }[] = [];
+
       const res = countBy(arr, (a) => a.x);
+
       expectType<typeof res, IMap<number, Uint32>>('=');
 
       expect(res.size).toBe(0);
     });
+
+    test('should work with curried version', () => {
+      const groupByParity = countBy((x: number) => x % 2);
+
+      const res = groupByParity([1, 2, 3, 4, 5, 6]);
+
+      const even = res.get(0);
+
+      expect(Optional.isSome(even)).toBe(true);
+
+      if (Optional.isSome(even)) {
+        expect(even.value).toBe(3);
+      }
+
+      const odd = res.get(1);
+
+      expect(Optional.isSome(odd)).toBe(true);
+
+      if (Optional.isSome(odd)) {
+        expect(odd.value).toBe(3);
+      }
+    });
   });
 
   describe(foldl, () => {
     test('empty array', () => {
       const result = foldl([], (acc, curr: number) => acc + curr, 0);
+
       expectType<typeof result, number>('=');
 
       expect(result).toBe(0);
@@ -325,6 +375,7 @@ describe('Arr reducing value', () => {
 
     test('sum numbers', () => {
       const result = foldl([1, 2, 3] as const, (acc, curr) => acc + curr, 0);
+
       expectType<typeof result, number>('=');
 
       expect(result).toBe(6);
@@ -336,15 +387,25 @@ describe('Arr reducing value', () => {
         (acc, curr) => acc + curr,
         '',
       );
+
       expectType<typeof result, string>('=');
 
       expect(result).toBe('abc');
     });
+
+    test('should work with curried version', () => {
+      const sumReduce = foldl((acc: number, curr: number) => acc + curr, 0);
+
+      const result = sumReduce([1, 2, 3, 4]);
+
+      expect(result).toBe(10);
+    });
   });
 
   describe(foldr, () => {
     test('empty array', () => {
       const result = foldr([], (acc, curr: number) => acc + curr, 0);
+
       expectType<typeof result, number>('=');
 
       expect(result).toBe(0);
@@ -353,6 +414,7 @@ describe('Arr reducing value', () => {
     test('subtract numbers from right', () => {
       // (1 - (2 - (3 - 0))) = 1 - (2 - 3) = 1 - (-1) = 2
       const result = foldr([1, 2, 3] as const, (acc, curr) => curr - acc, 0);
+
       expectType<typeof result, number>('=');
 
       expect(result).toBe(2); // 3 - (2 - (1 - 0)) = 3 - (2 - 1) = 3 - 1 = 2.  No, this is (acc, curr) => acc - curr.
@@ -369,6 +431,7 @@ describe('Arr reducing value', () => {
         (acc, curr) => curr + acc,
         '',
       );
+
       expectType<typeof result, string>('=');
 
       expect(result).toBe('abc'); // c + (b + (a + "")) = cba. No, it's curr + acc.
@@ -376,11 +439,20 @@ describe('Arr reducing value', () => {
       // Iteration 2: prev = "c", curr = "b". Result = "b" + "c" = "bc".
       // Iteration 3: prev = "bc", curr = "a". Result = "a" + "bc" = "abc".
     });
+
+    test('should work with curried version', () => {
+      const productReduce = foldr((acc: number, curr: number) => acc * curr, 1);
+
+      const result = productReduce([2, 3, 4]);
+
+      expect(result).toBe(24); // 1 * 4 * 3 * 2 = 24
+    });
   });
 
   describe(sum, () => {
     test('empty array', () => {
       const result = sum([]);
+
       expectType<typeof result, 0>('=');
 
       expect(result).toBe(0);
@@ -388,6 +460,7 @@ describe('Arr reducing value', () => {
 
     test('one element array', () => {
       const result = sum([23]);
+
       expectType<typeof result, 23>('=');
 
       expect(result).toBe(23);
@@ -395,6 +468,7 @@ describe('Arr reducing value', () => {
 
     test('positive numbers', () => {
       const result = sum([1, 2, 3, 4, 5] as const);
+
       expectType<typeof result, number>('=');
 
       expect(result).toBe(15);
@@ -402,6 +476,7 @@ describe('Arr reducing value', () => {
 
     test('mixed numbers', () => {
       const result = sum([1, -2, 3, 0, -5] as const);
+
       expectType<typeof result, number>('=');
 
       expect(result).toBe(-3);
@@ -411,6 +486,7 @@ describe('Arr reducing value', () => {
   describe(join, () => {
     test('should join array elements', () => {
       const arr = ['Hello', 'World'];
+
       const result = join(arr, ' ');
 
       expect(Result.isOk(result)).toBe(true);
@@ -422,6 +498,7 @@ describe('Arr reducing value', () => {
 
     test('should handle empty separator', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = join(arr, '');
 
       expect(Result.isOk(result)).toBe(true);
@@ -433,6 +510,7 @@ describe('Arr reducing value', () => {
 
     test('should handle undefined separator', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = join(arr);
 
       expect(Result.isOk(result)).toBe(true);
@@ -441,5 +519,17 @@ describe('Arr reducing value', () => {
         expect(result.value).toBe('a,b,c');
       }
     });
+
+    test('should work with curried version', () => {
+      const joinWithDash = join('-');
+
+      const result = joinWithDash(['x', 'y', 'z']);
+
+      expect(Result.isOk(result)).toBe(true);
+
+      if (Result.isOk(result)) {
+        expect(result.value).toBe('x-y-z');
+      }
+    });
   });
 });