ts-data-forge 5.0.1 → 5.1.1

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

@@ -18,40 +18,45 @@ describe('Arr reducing value', () => {
   describe(min, () => {
     {
       const xs = [3, 5, 4] as const;
+
       const result = min(xs);
 
       expectType<typeof result, Some<3 | 4 | 5>>('=');
 
       test('case 1', () => {
-        expect(Optional.isSome(result)).toBe(true);
+        assert.isTrue(Optional.isSome(result));
 
         if (Optional.isSome(result)) {
           expect(result.value).toBe(3);
         }
       });
     }
+
     {
       const xs = [3, 5, 4] as const;
+
       const result = min(xs, (a, b) => a - b);
 
       expectType<typeof result, Some<3 | 4 | 5>>('=');
 
       test('case 2', () => {
-        expect(Optional.isSome(result)).toBe(true);
+        assert.isTrue(Optional.isSome(result));
 
         if (Optional.isSome(result)) {
           expect(result.value).toBe(3);
         }
       });
     }
+
     {
       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>>('=');
 
       test('case 3', () => {
-        expect(Optional.isSome(result)).toBe(true);
+        assert.isTrue(Optional.isSome(result));
 
         if (Optional.isSome(result)) {
           expect(result.value).toBe(3);
@@ -62,12 +67,13 @@ 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>>('=');
 
     test('case 1', () => {
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         expect(result.value).toBe(5);
@@ -76,9 +82,10 @@ 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);
+      assert.isTrue(Optional.isSome(res));
 
       if (Optional.isSome(res)) {
         expect(res.value).toBe(5);
@@ -87,10 +94,12 @@ 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);
+      assert.isTrue(Optional.isSome(res));
 
       if (Optional.isSome(res)) {
         expect(res.value).toBe(5);
@@ -99,10 +108,12 @@ 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);
+      assert.isTrue(Optional.isNone(res));
     });
   });
 
@@ -133,7 +144,7 @@ describe('Arr reducing value', () => {
     >('=');
 
     test('case 1', () => {
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         assert.deepStrictEqual(result.value, { x: 1, y: 2 });
@@ -142,10 +153,12 @@ 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);
+      assert.isTrue(Optional.isNone(res));
     });
 
     test('case 3: custom comparator', () => {
@@ -172,7 +185,7 @@ describe('Arr reducing value', () => {
         >
       >('=');
 
-      expect(Optional.isSome(res)).toBe(true);
+      assert.isTrue(Optional.isSome(res));
 
       if (Optional.isSome(res)) {
         assert.deepStrictEqual(res.value, { name: 'apple', score: 10 });
@@ -207,7 +220,7 @@ describe('Arr reducing value', () => {
     >('=');
 
     test('case 1', () => {
-      expect(Optional.isSome(result)).toBe(true);
+      assert.isTrue(Optional.isSome(result));
 
       if (Optional.isSome(result)) {
         assert.deepStrictEqual(result.value, { x: 6, y: 1 });
@@ -216,10 +229,12 @@ 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);
+      assert.isTrue(Optional.isNone(res));
     });
 
     test('case 3: custom comparator', () => {
@@ -246,7 +261,7 @@ describe('Arr reducing value', () => {
         >
       >('=');
 
-      expect(Optional.isSome(res)).toBe(true);
+      assert.isTrue(Optional.isSome(res));
 
       if (Optional.isSome(res)) {
         assert.deepStrictEqual(res.value, { name: 'cherry', score: 12 });
@@ -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);
+
+      assert.isTrue(Optional.isSome(even));
+
+      if (Optional.isSome(even)) {
+        expect(even.value).toBe(3);
+      }
+
+      const odd = res.get(1);
+
+      assert.isTrue(Optional.isSome(odd));
+
+      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,35 +486,42 @@ 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);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe('Hello World');
-      }
+      expect(result.value).toBe('Hello World');
     });
 
     test('should handle empty separator', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = join(arr, '');
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe('abc');
-      }
+      expect(result.value).toBe('abc');
     });
 
     test('should handle undefined separator', () => {
       const arr = ['a', 'b', 'c'];
+
       const result = join(arr);
 
-      expect(Result.isOk(result)).toBe(true);
+      assert.isTrue(Result.isOk(result));
 
-      if (Result.isOk(result)) {
-        expect(result.value).toBe('a,b,c');
-      }
+      expect(result.value).toBe('a,b,c');
+    });
+
+    test('should work with curried version', () => {
+      const joinWithDash = join('-');
+
+      const result = joinWithDash(['x', 'y', 'z']);
+
+      assert.isTrue(Result.isOk(result));
+
+      expect(result.value).toBe('x-y-z');
     });
   });
 });

package/src/array/impl/array-utils-search.mts

@@ -14,9 +14,11 @@ import { asUint32 } from '../../number/index.mjs';
  * ];
  *
  * const found = Arr.find(users, (user) => user.id === 2);
+ *
  * const missing = Arr.find<{ id: number }>((user) => user.id === 3)(users);
  *
  * assert.deepStrictEqual(found, Optional.some({ id: 2, name: 'Grace' }));
+ *
  * assert.deepStrictEqual(missing, Optional.none);
  * ```
  */
@@ -55,6 +57,7 @@ export function find<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       const foundIndex = array.findIndex(
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
         predicate as () => boolean,
@@ -75,6 +78,7 @@ export function find<E>(
         : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
           Optional.some(array[foundIndex]!);
     }
+
     case 1: {
       const [predicate] = args;
 
@@ -97,9 +101,11 @@ export function find<E>(
  * const numbers = [1, 3, 2, 4, 5];
  *
  * const lastEven = Arr.findLast(numbers, (n) => n % 2 === 0);
+ *
  * const none = Arr.findLast<number>((n) => n > 10)(numbers);
  *
  * assert.deepStrictEqual(lastEven, Optional.some(4));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */
@@ -138,6 +144,7 @@ export function findLast<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       const foundIndex = array.findLastIndex(
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
         predicate as () => boolean,
@@ -158,6 +165,7 @@ export function findLast<E>(
         : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
           Optional.some(array[foundIndex]!);
     }
+
     case 1: {
       const [predicate] = args;
 
@@ -180,13 +188,15 @@ export function findLast<E>(
  * const letters = ['a', 'b', 'c'];
  *
  * const indexOfB = Arr.findIndex(letters, (letter) => letter === 'b');
+ *
  * // eslint-disable-next-line unicorn/prefer-array-index-of
  * const indexOfMissing = Arr.findIndex<string>((letter) => letter === 'z')(
  *   letters,
  * );
  *
- * assert(indexOfB === 1);
- * assert(indexOfMissing === -1);
+ * assert.isTrue(indexOfB === 1);
+ *
+ * assert.isTrue(indexOfMissing === -1);
  * ```
  */
 export function findIndex<const Ar extends readonly unknown[]>(
@@ -219,6 +229,7 @@ export function findIndex<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       return pipe(
         array.findIndex(
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -226,8 +237,10 @@ export function findIndex<E>(
         ),
       ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
     }
+
     case 1: {
       const [predicate] = args;
+
       return (array) => findIndex(array, predicate);
     }
   }
@@ -242,11 +255,13 @@ export function findIndex<E>(
  * const letters = ['a', 'b', 'c', 'b'];
  *
  * const lastIndexOfB = Arr.findLastIndex(letters, (letter) => letter === 'b');
+ *
  * // eslint-disable-next-line unicorn/prefer-array-index-of
  * const notFound = Arr.findLastIndex<string>((letter) => letter === 'z')(letters);
  *
- * assert(lastIndexOfB === 3);
- * assert(notFound === -1);
+ * assert.isTrue(lastIndexOfB === 3);
+ *
+ * assert.isTrue(notFound === -1);
  * ```
  */
 export function findLastIndex<const Ar extends readonly unknown[]>(
@@ -279,6 +294,7 @@ export function findLastIndex<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       return pipe(
         array.findLastIndex(
           // eslint-disable-next-line total-functions/no-unsafe-type-assertion
@@ -286,8 +302,10 @@ export function findLastIndex<E>(
         ),
       ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
     }
+
     case 1: {
       const [predicate] = args;
+
       return (array) => findLastIndex(array, predicate);
     }
   }
@@ -302,14 +320,18 @@ export function findLastIndex<E>(
  * const fruits = ['apple', 'banana', 'orange', 'banana'];
  *
  * const indexOfBanana = Arr.indexOf(fruits, 'banana');
+ *
  * const indexOfGrape = Arr.indexOf(fruits, 'grape');
  *
  * // Curried version
  * const findApple = Arr.indexOf('apple');
+ *
  * const indexOfApple = findApple(fruits);
  *
  * console.log(indexOfBanana); // => 1
+ *
  * console.log(indexOfGrape); // => -1
+ *
  * console.log(indexOfApple); // => 0
  * ```
  */
@@ -332,10 +354,13 @@ export function indexOf<E>(
       const [array, searchElement] = args;
 
       const index = array.indexOf(searchElement);
+
       return index !== -1 ? asUint32(index) : -1;
     }
+
     case 1: {
       const [searchElement] = args;
+
       return (array) => indexOf(array, searchElement);
     }
   }
@@ -351,18 +376,24 @@ export function indexOf<E>(
  *
  * // Search for 'banana' starting from index 1
  * const firstBanana = Arr.indexOfFrom(fruits, 'banana', 1);
+ *
  * // Search for 'banana' starting from index 2
  * const secondBanana = Arr.indexOfFrom(fruits, 'banana', 2);
+ *
  * // Element not found
  * const notFound = Arr.indexOfFrom(fruits, 'grape', 0);
  *
  * // Curried version
  * const findBananaFrom2 = Arr.indexOfFrom('banana', 2);
+ *
  * const index = findBananaFrom2(fruits);
  *
  * console.log(firstBanana); // => 1
+ *
  * console.log(secondBanana); // => 3
+ *
  * console.log(notFound); // => -1
+ *
  * console.log(index); // => 3
  * ```
  */
@@ -389,11 +420,15 @@ export function indexOfFrom<E>(
   switch (args.length) {
     case 3: {
       const [array, searchElement, fromIndex] = args;
+
       const index = array.indexOf(searchElement, fromIndex);
+
       return index !== -1 ? asUint32(index) : -1;
     }
+
     case 2: {
       const [searchElement, fromIndex] = args;
+
       return (array) => indexOfFrom(array, searchElement, fromIndex);
     }
   }
@@ -408,16 +443,22 @@ export function indexOfFrom<E>(
  * const fruits = ['apple', 'banana', 'orange', 'banana'];
  *
  * const lastBanana = Arr.lastIndexOf(fruits, 'banana');
+ *
  * const lastApple = Arr.lastIndexOf(fruits, 'apple');
+ *
  * const notFound = Arr.lastIndexOf(fruits, 'grape');
  *
  * // Curried version
  * const findLastBanana = Arr.lastIndexOf('banana');
+ *
  * const index = findLastBanana(fruits);
  *
  * console.log(lastBanana); // => 3
+ *
  * console.log(lastApple); // => 0
+ *
  * console.log(notFound); // => -1
+ *
  * console.log(index); // => 3
  * ```
  */
@@ -438,11 +479,15 @@ export function lastIndexOf<E>(
   switch (args.length) {
     case 2: {
       const [array, searchElement] = args;
+
       const index = array.lastIndexOf(searchElement);
+
       return index !== -1 ? asUint32(index) : -1;
     }
+
     case 1: {
       const [searchElement] = args;
+
       return (array) => lastIndexOf(array, searchElement);
     }
   }
@@ -458,18 +503,24 @@ export function lastIndexOf<E>(
  *
  * // Search backwards for 'banana' from index 3
  * const lastBananaFrom3 = Arr.lastIndexOfFrom(fruits, 'banana', 3);
+ *
  * // Search backwards for 'banana' from index 2
  * const lastBananaFrom2 = Arr.lastIndexOfFrom(fruits, 'banana', 2);
+ *
  * // Element not found
  * const notFound = Arr.lastIndexOfFrom(fruits, 'grape', 2);
  *
  * // Curried version
  * const findBananaFrom3 = Arr.lastIndexOfFrom('banana', 3);
+ *
  * const index = findBananaFrom3(fruits);
  *
  * console.log(lastBananaFrom3); // => 3
+ *
  * console.log(lastBananaFrom2); // => 1
+ *
  * console.log(notFound); // => -1
+ *
  * console.log(index); // => 3
  * ```
  */
@@ -501,8 +552,10 @@ export function lastIndexOfFrom<E>(
 
       return index !== -1 ? asUint32(index) : -1;
     }
+
     case 2: {
       const [searchElement, fromIndex] = args;
+
       return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
     }
   }