ts-data-forge 3.2.0 → 3.3.1

package/src/array/{array-utils-transformation.test.mts → impl/array-utils-transformation.test.mts}

@@ -1,151 +1,185 @@
-import { IMap } from '../collections/index.mjs';
-import { expectType } from '../expect-type.mjs';
-import { Optional } from '../functional/index.mjs';
-import { SafeUint } from '../number/index.mjs';
-import { Arr } from './array-utils.mjs';
+import { IMap } from '../../collections/index.mjs';
+import { expectType } from '../../expect-type.mjs';
+import { Optional } from '../../functional/index.mjs';
+import { SafeUint } from '../../number/index.mjs';
+import {
+  concat,
+  filter,
+  filterNot,
+  flat,
+  flatMap,
+  groupBy,
+  map,
+  partition,
+  scan,
+  toReversed,
+  toSorted,
+  toSortedBy,
+  uniq,
+  uniqBy,
+  zip,
+} from './array-utils-transformation.mjs';
 
 describe('Arr transformations', () => {
-  describe('partition', () => {
-    const xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] as const;
+  describe('map', () => {
+    const mapped = map([1, 2, 3], (x, i): number => x * x * i);
 
-    {
-      const result = Arr.partition(xs, 4);
+    expectType<typeof mapped, ArrayOfLength<3, number>>('=');
 
-      expectType<
-        typeof result,
-        readonly (readonly (
-          | 1
-          | 2
-          | 3
-          | 4
-          | 5
-          | 6
-          | 7
-          | 8
-          | 9
-          | 10
-          | 11
-          | 12
-        )[])[]
-      >('=');
+    test('case 1', () => {
+      expect(mapped).toStrictEqual([0, 4, 18]);
+    });
 
-      test('case 1', () => {
-        expect(result).toStrictEqual([
-          [1, 2, 3, 4],
-          [5, 6, 7, 8],
-          [9, 10, 11, 12],
-        ]);
-      });
-    }
+    test('should work with empty tuple', () => {
+      const empty = [] as const;
+      const mappedEmpty = map(empty, (x) => String(x));
+      expectType<typeof mappedEmpty, readonly []>('=');
+      expect(mappedEmpty).toStrictEqual([]);
+    });
 
-    {
-      const result = Arr.partition(xs, 3);
+    test('should preserve tuple length with different types', () => {
+      const mixed = [1, 'hello', true] as const;
+      const mappedMixed = map(mixed, (x) => typeof x);
+      expectType<typeof mappedMixed, readonly [string, string, string]>('<=');
+      expect(mappedMixed).toStrictEqual(['number', 'string', 'boolean']);
+    });
 
-      expectType<
-        typeof result,
-        readonly (readonly (
-          | 1
-          | 2
-          | 3
-          | 4
-          | 5
-          | 6
-          | 7
-          | 8
-          | 9
-          | 10
-          | 11
-          | 12
-        )[])[]
-      >('=');
+    test('should work with index parameter', () => {
+      const tuple = ['a', 'b', 'c'] as const;
+      const mappedWithIndex = map(tuple, (x, i) => `${i}:${x}`);
+      expectType<typeof mappedWithIndex, readonly [string, string, string]>(
+        '<=',
+      );
+      expect(mappedWithIndex).toStrictEqual(['0:a', '1:b', '2:c']);
+    });
+  });
 
-      test('case 2', () => {
-        expect(result).toStrictEqual([
-          [1, 2, 3],
-          [4, 5, 6],
-          [7, 8, 9],
-          [10, 11, 12],
-        ]);
-      });
-    }
+  describe('scan', () => {
+    test('should compute running sum', () => {
+      const numbers = [1, 2, 3, 4];
+      const runningSum = scan(numbers, (acc, curr) => acc + curr, 0);
 
-    {
-      const result = Arr.partition(xs, 5);
+      expectType<typeof runningSum, readonly [number, ...number[]]>('<=');
+      expect(runningSum).toStrictEqual([0, 1, 3, 6, 10]);
+    });
 
-      expectType<
-        typeof result,
-        readonly (readonly (
-          | 1
-          | 2
-          | 3
-          | 4
-          | 5
-          | 6
-          | 7
-          | 8
-          | 9
-          | 10
-          | 11
-          | 12
-        )[])[]
-      >('=');
+    test('should include initial value as first element', () => {
+      const numbers = [10, 20, 30];
+      const result = scan(numbers, (acc, curr) => acc + curr, 100);
 
-      test('case 3', () => {
-        expect(result).toStrictEqual([
-          [1, 2, 3, 4, 5],
-          [6, 7, 8, 9, 10],
-          [11, 12],
-        ]);
-      });
-    }
+      expect(result).toStrictEqual([100, 110, 130, 160]);
+      expect(result).toHaveLength(4); // original length + 1
+    });
 
-    test('should partition array into chunks', () => {
-      const numbers = [1, 2, 3, 4, 5, 6];
-      const result = Arr.partition(numbers, 2);
+    test('should work with curried version', () => {
+      const scanSum = scan<number, number>((acc, curr) => acc + curr, 0);
 
-      expect(result).toStrictEqual([
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ]);
+      const result1 = scanSum([1, 2, 3]);
+      const result2 = scanSum([5, 10]);
+
+      expect(result1).toStrictEqual([0, 1, 3, 6]);
+      expect(result2).toStrictEqual([0, 5, 15]);
     });
 
-    test('should handle arrays not evenly divisible by chunk size', () => {
-      const numbers = [1, 2, 3, 4, 5];
-      const result = Arr.partition(numbers, 2);
+    test('should provide index to reducer', () => {
+      const numbers = [10, 20, 30];
+      const mut_indices: number[] = [];
 
-      expect(result).toStrictEqual([[1, 2], [3, 4], [5]]);
+      scan(
+        numbers,
+        (acc, curr, index) => {
+          mut_indices.push(index);
+          return acc + curr;
+        },
+        0,
+      );
+
+      expect(mut_indices).toStrictEqual([0, 1, 2]);
     });
 
-    test('should work with chunk size < 2 (returns empty)', () => {
+    test('should work with empty array', () => {
+      const empty: readonly number[] = [];
+      const result = scan(empty, (acc, curr) => acc + curr, 42);
+
+      expect(result).toStrictEqual([42]);
+    });
+
+    test('should work with different accumulator and element types', () => {
+      const strings = ['a', 'b', 'c'];
+      const result = scan(strings, (acc, curr) => acc + curr.length, 0);
+
+      expectType<typeof result, readonly [number, ...number[]]>('<=');
+      expect(result).toStrictEqual([0, 1, 2, 3]);
+    });
+
+    test('should compute running product', () => {
+      const numbers = [2, 3, 4];
+      const runningProduct = scan(numbers, (acc, curr) => acc * curr, 1);
+
+      expect(runningProduct).toStrictEqual([1, 2, 6, 24]);
+    });
+
+    test('should work with objects', () => {
+      const items = [{ value: 10 }, { value: 20 }, { value: 30 }] as const;
+
+      const result = scan(items, (acc, curr) => acc + curr.value, 0);
+
+      expect(result).toStrictEqual([0, 10, 30, 60]);
+    });
+
+    test('should preserve all intermediate values', () => {
       const numbers = [1, 2, 3];
-      const result = Arr.partition(numbers, 1);
+      const result = scan(numbers, (acc, curr) => acc - curr, 10);
 
-      // According to docs, returns empty array if chunkSize < 2
-      expect(result).toStrictEqual([]);
+      // 10 -> 10-1=9 -> 9-2=7 -> 7-3=4
+      expect(result).toStrictEqual([10, 9, 7, 4]);
     });
+  });
 
-    test('should work with chunk size larger than array', () => {
-      const numbers = [1, 2];
-      const result = Arr.partition(numbers, 5);
+  describe('toReversed', () => {
+    {
+      const xs = [1, 2, 3] as const;
+      const _nativeResult = xs.toReversed();
 
-      expect(result).toStrictEqual([[1, 2]]);
+      expectType<typeof _nativeResult, (1 | 2 | 3)[]>('=');
+
+      const result = toReversed([1, 2, 3]);
+
+      expectType<typeof result, readonly [3, 2, 1]>('=');
+
+      test('case 1', () => {
+        expect(result).toStrictEqual([3, 2, 1]);
+      });
+    }
+
+    test('should work with empty tuple', () => {
+      const empty = [] as const;
+      const reversed = toReversed(empty);
+      expectType<typeof reversed, readonly []>('=');
+      expect(reversed).toStrictEqual([]);
     });
 
-    test('partition should work with empty array', () => {
-      const empty: readonly number[] = [];
-      const result = Arr.partition(empty, 2);
+    test('should work with single element', () => {
+      const single = [42] as const;
+      const reversed = toReversed(single);
+      expectType<typeof reversed, readonly [42]>('=');
+      expect(reversed).toStrictEqual([42]);
+    });
 
-      expect(result).toStrictEqual([]);
+    test('should preserve mixed types in reverse order', () => {
+      const mixed = [1, 'hello', true, null] as const;
+      const reversed = toReversed(mixed);
+      expectType<typeof reversed, readonly [null, true, 'hello', 1]>('=');
+      expect(reversed).toStrictEqual([null, true, 'hello', 1]);
     });
   });
 
   describe('toSorted', () => {
     {
       const xs = [2, 1, 3] as const;
-      const result = xs.toSorted();
+      const result = toSorted(xs);
 
-      expectType<typeof result, (1 | 2 | 3)[]>('=');
+      expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
 
       test('case 1', () => {
         expect(result).toStrictEqual([1, 2, 3]);
@@ -153,9 +187,9 @@ describe('Arr transformations', () => {
     }
     {
       const xs = [2, 1, 3] as const;
-      const result = xs.toSorted((a, b) => a - b);
+      const result = toSorted(xs, (a, b) => a - b);
 
-      expectType<typeof result, (1 | 2 | 3)[]>('=');
+      expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
 
       test('case 2', () => {
         expect(result).toStrictEqual([1, 2, 3]);
@@ -163,9 +197,9 @@ describe('Arr transformations', () => {
     }
     {
       const xs = [2, 1, 3] as const;
-      const result = xs.toSorted((a, b) => b - a);
+      const result = toSorted(xs, (a, b) => b - a);
 
-      expectType<typeof result, (1 | 2 | 3)[]>('=');
+      expectType<typeof result, ArrayOfLength<3, 1 | 2 | 3>>('=');
 
       test('case 3', () => {
         expect(result).toStrictEqual([3, 2, 1]);
@@ -176,7 +210,7 @@ describe('Arr transformations', () => {
   describe('toSortedBy', () => {
     {
       const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
-      const sorted = Arr.toSortedBy(xs, (x) => x.v);
+      const sorted = toSortedBy(xs, (x) => x.v);
 
       expectType<
         typeof sorted,
@@ -189,7 +223,7 @@ describe('Arr transformations', () => {
     }
     {
       const xs = [{ v: 2 }, { v: 1 }, { v: 3 }] as const;
-      const sorted = Arr.toSortedBy(
+      const sorted = toSortedBy(
         xs,
         (x) => x.v,
         (a, b) => a - b,
@@ -211,7 +245,7 @@ describe('Arr transformations', () => {
         { name: 'Bob', age: 20 },
         { name: 'Charlie', age: 25 },
       ];
-      const result = Arr.toSortedBy(people, (person) => person.age);
+      const result = toSortedBy(people, (person) => person.age);
 
       expect(result).toHaveLength(3);
       expect(result[0]?.name).toBe('Bob');
@@ -221,7 +255,7 @@ describe('Arr transformations', () => {
 
     test('should work with string sorting', () => {
       const words = ['banana', 'apple', 'cherry'];
-      const result = Arr.toSortedBy(
+      const result = toSortedBy(
         words,
         (word: string) => word,
         (a: string, b: string) => a.localeCompare(b),
@@ -231,267 +265,81 @@ describe('Arr transformations', () => {
 
     test('should work with custom key extraction', () => {
       const items = ['hello', 'hi', 'welcome', 'bye'];
-      const result = Arr.toSortedBy(items, (item) => item.length);
+      const result = toSortedBy(items, (item) => item.length);
       expect(result).toStrictEqual(['hi', 'bye', 'hello', 'welcome']);
     });
 
     test('should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
-      const result = Arr.toSortedBy(empty, (item) => item.value);
+      const result = toSortedBy(empty, (item) => item.value);
       expect(result).toStrictEqual([]);
     });
 
     test('toSortedBy should work with empty array', () => {
       const empty: readonly { value: number }[] = [];
-      const result = Arr.toSortedBy(empty, (item) => item.value);
+      const result = toSortedBy(empty, (item) => item.value);
       expect(result).toStrictEqual([]);
     });
   });
 
-  describe('groupBy', () => {
-    const xs = [
-      { x: 1, y: 1 },
-      { x: 2, y: 1 },
-      { x: 3, y: 1 },
-      { x: 1, y: 2 },
-      { x: 2, y: 2 },
-      { x: 1, y: 3 },
-    ] as const;
+  describe('filter', () => {
+    test('should filter array with predicate', () => {
+      const numbers = [1, 2, 3, 4, 5];
+      const evens = filter(numbers, (n) => n % 2 === 0);
+      expect(evens).toStrictEqual([2, 4]);
+    });
 
-    const result = Arr.groupBy(xs, (a) => a.x);
+    test('should work with type guards', () => {
+      const mixed: (string | number | null)[] = [
+        'hello',
+        42,
+        null,
+        'world',
+        123,
+      ];
+      const strings = filter(mixed, (x): x is string => typeof x === 'string');
+      expectType<typeof strings, readonly string[]>('=');
+      expect(strings).toStrictEqual(['hello', 'world']);
+    });
 
-    expectType<
-      typeof result,
-      IMap<
-        1 | 2 | 3,
-        readonly (
-          | Readonly<{ x: 1; y: 1 }>
-          | Readonly<{ x: 1; y: 2 }>
-          | Readonly<{ x: 1; y: 3 }>
-          | Readonly<{ x: 2; y: 1 }>
-          | Readonly<{ x: 2; y: 2 }>
-          | Readonly<{ x: 3; y: 1 }>
-        )[]
-      >
-    >('=');
+    test('should work with curried version', () => {
+      const isPositive = (n: number): boolean => n > 0;
+      const filterPositive = filter(isPositive);
+      const result = filterPositive([-1, 2, -3, 4]);
+      expect(result).toStrictEqual([2, 4]);
+    });
 
-    test('case 1', () => {
-      expect(result).toStrictEqual(
-        IMap.create<
-          1 | 2 | 3,
-          readonly (
-            | Readonly<{ x: 1; y: 1 }>
-            | Readonly<{ x: 1; y: 2 }>
-            | Readonly<{ x: 1; y: 3 }>
-            | Readonly<{ x: 2; y: 1 }>
-            | Readonly<{ x: 2; y: 2 }>
-            | Readonly<{ x: 3; y: 1 }>
-          )[]
-        >([
-          [
-            1,
-            [
-              { x: 1, y: 1 },
-              { x: 1, y: 2 },
-              { x: 1, y: 3 },
-            ],
-          ],
-          [
-            2,
-            [
-              { x: 2, y: 1 },
-              { x: 2, y: 2 },
-            ],
-          ],
-          [3, [{ x: 3, y: 1 }]],
-        ]),
-      );
+    test('should work with curried type guards', () => {
+      const isString = (x: unknown): x is string => typeof x === 'string';
+      const filterStrings = filter(isString);
+      const result = filterStrings(['a', 1, 'b', 2]);
+      expectType<typeof result, readonly string[]>('=');
+      expect(result).toStrictEqual(['a', 'b']);
     });
 
-    test('should group elements by key', () => {
-      const array = [
-        { type: 'fruit', name: 'apple' },
-        { type: 'vegetable', name: 'carrot' },
-        { type: 'fruit', name: 'banana' },
-      ];
-      const grouped = Arr.groupBy(array, (item) => item.type);
-
-      expect(grouped.size).toBe(2);
-      const fruits = grouped.get('fruit');
-      const vegetables = grouped.get('vegetable');
-
-      expect(Optional.isSome(fruits)).toBe(true);
-      expect(Optional.isSome(vegetables)).toBe(true);
-
-      if (Optional.isSome(fruits)) {
-        expect(fruits.value).toHaveLength(2);
-        expect(fruits.value[0]?.name).toBe('apple');
-        expect(fruits.value[1]?.name).toBe('banana');
-      }
-
-      if (Optional.isSome(vegetables)) {
-        expect(vegetables.value).toHaveLength(1);
-        expect(vegetables.value[0]?.name).toBe('carrot');
-      }
-    });
-
-    test('should work with numeric keys', () => {
-      const numbers = [1, 2, 3, 4, 5, 6];
-      const grouped = Arr.groupBy(numbers, (n) => n % 2);
-
-      expect(grouped.size).toBe(2);
-      const evens = grouped.get(0);
-      const odds = grouped.get(1);
-
-      if (Optional.isSome(evens)) {
-        expect(evens.value).toStrictEqual([2, 4, 6]);
-      }
-
-      if (Optional.isSome(odds)) {
-        expect(odds.value).toStrictEqual([1, 3, 5]);
-      }
+    test('should preserve array type with generic predicate', () => {
+      const tuple = [1, 2, 3] as const;
+      const filtered = filter(tuple, (x) => x > 1);
+      expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
+      expect(filtered).toStrictEqual([2, 3]);
     });
 
     test('should work with empty array', () => {
-      const empty: readonly number[] = [];
-      const grouped = Arr.groupBy(empty, (n) => n % 2);
-      expect(grouped.size).toBe(0);
-    });
-
-    test('should handle all elements in same group', () => {
-      const array = [1, 2, 3, 4];
-      const grouped = Arr.groupBy(array, () => 'all');
-
-      expect(grouped.size).toBe(1);
-      const all = grouped.get('all');
-
-      if (Optional.isSome(all)) {
-        expect(all.value).toStrictEqual([1, 2, 3, 4]);
-      }
-    });
-  });
-
-  describe('zip', () => {
-    {
-      const xs = [1, 2, 3] as const;
-      const ys = [4, 5, 6] as const;
-      const zipped = Arr.zip(xs, ys);
-
-      expectType<
-        typeof zipped,
-        readonly [readonly [1, 4], readonly [2, 5], readonly [3, 6]]
-      >('=');
-
-      test('case 1', () => {
-        expect(zipped).toStrictEqual([
-          [1, 4],
-          [2, 5],
-          [3, 6],
-        ]);
-      });
-    }
-    {
-      const xs: readonly number[] = [1, 2, 3];
-      const ys: readonly number[] = [4];
-      const zipped = Arr.zip(xs, ys);
-
-      expectType<typeof zipped, readonly (readonly [number, number])[]>('=');
-
-      test('case 2', () => {
-        expect(zipped).toStrictEqual([[1, 4]]);
-      });
-    }
-    {
-      const xs = [1] as const;
-      const ys: readonly number[] = [4, 5, 6];
-      const zipped = Arr.zip(xs, ys);
-
-      expectType<typeof zipped, readonly [readonly [1, number]]>('=');
-
-      test('case 3', () => {
-        expect(zipped).toStrictEqual([[1, 4]]);
-      });
-    }
-
-    // testArrayEquality({
-    //   testName: 'zip',
-    //   target: zip([0, 1, 2, 3, 4], [5, 6, 7, 8, 9]),
-    //   toBe: [
-    //     [0, 5],
-    //     [1, 6],
-    //     [2, 7],
-    //     [3, 8],
-    //     [4, 9],
-    //   ],
-    // });
-
-    // testArrayEquality({
-    //   testName: 'zipArrays 2 arrays',
-    //   target: zipArrays([0, 1, 2, 3, 4], [5, 6, 7, 8, 9]),
-    //   toBe: [
-    //     [0, 5],
-    //     [1, 6],
-    //     [2, 7],
-    //     [3, 8],
-    //     [4, 9],
-    //   ],
-    // });
-
-    // testArrayEquality({
-    //   testName: 'zipArrays 3 arrays',
-    //   target: zipArrays(
-    //     [0, 1, 2, 3, 4],
-    //     [5, 6, 7, 8, 9, 999, 999],
-    //     [10, 11, 12, 13, 14, 999]
-    //   ),
-    //   toBe: [
-    //     [0, 5, 10],
-    //     [1, 6, 11],
-    //     [2, 7, 12],
-    //     [3, 8, 13],
-    //     [4, 9, 14],
-    //   ],
-    // });
-
-    test('should zip two arrays', () => {
-      const arr1 = [1, 2, 3];
-      const arr2 = ['a', 'b', 'c'];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([
-        [1, 'a'],
-        [2, 'b'],
-        [3, 'c'],
-      ]);
-    });
-
-    test('should handle arrays of different lengths', () => {
-      const arr1 = [1, 2, 3, 4];
-      const arr2 = ['a', 'b'];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([
-        [1, 'a'],
-        [2, 'b'],
-      ]);
-    });
-
-    test('should work with empty arrays', () => {
-      const arr1: readonly number[] = [];
-      const arr2: readonly string[] = [];
-      const result = Arr.zip(arr1, arr2);
+      const empty: number[] = [];
+      const result = filter(empty, (n) => n > 0);
       expect(result).toStrictEqual([]);
     });
 
-    test('should handle one empty array', () => {
-      const arr1 = [1, 2, 3];
-      const arr2: readonly string[] = [];
-      const result = Arr.zip(arr1, arr2);
-      expect(result).toStrictEqual([]);
+    test('should pass index to predicate', () => {
+      const numbers = [10, 20, 30, 40];
+      const evenIndexes = filter(numbers, (_, i) => i % 2 === 0);
+      expect(evenIndexes).toStrictEqual([10, 30]);
     });
   });
 
   describe('filterNot', () => {
     const xs = [1, 2, 3] as const;
-    const filtered = Arr.filterNot(xs, (x) => x % 2 === 0);
+    const filtered = filterNot(xs, (x) => x % 2 === 0);
 
     expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
 
@@ -500,70 +348,28 @@ describe('Arr transformations', () => {
     });
   });
 
-  describe('concat', () => {
-    const xs = [1, 2, 3] as const;
-    const ys = [4, 5] as const;
-    const result = Arr.concat(xs, ys);
-
-    expectType<typeof result, readonly [1, 2, 3, 4, 5]>('=');
-
-    test('case 1', () => {
-      expect(result).toStrictEqual([1, 2, 3, 4, 5]);
-    });
-
-    // testArrayEquality({
-    //   testName: 'concat 2 arrays',
-    //   target: concat([1, 2, 3], [4, 5, 6]),
-    //   toBe: [1, 2, 3, 4, 5, 6],
-    // });
-
-    // testArrayEquality({
-    //   testName: 'concat 2 arrays',
-    //   target: concat([1, 2, 3], []),
-    //   toBe: [1, 2, 3],
-    // });
-
-    // testArrayEquality({
-    //   testName: 'concat 2 arrays',
-    //   target: concat([], [4, 5, 6]),
-    //   toBe: [4, 5, 6],
-    // });
-
-    // testArrayEquality({
-    //   testName: 'concat 2 arrays',
-    //   target: concat([], []),
-    //   toBe: [],
-    // });
-
-    // testArrayEquality({
-    //   testName: 'concat 2 arrays',
-    //   target: concat(['1', '2', '3'], [4, 5, 6]),
-    //   toBe: ['1', '2', '3', 4, 5, 6],
-    // });
-  });
-
   describe('uniq', () => {
     test('should remove duplicate primitives', () => {
       const array = [1, 2, 2, 3, 1, 4, 3];
-      const result = Arr.uniq(array);
+      const result = uniq(array);
       expect(result).toStrictEqual([1, 2, 3, 4]);
     });
 
     test('should work with strings', () => {
       const array = ['a', 'b', 'a', 'c', 'b'];
-      const result = Arr.uniq(array);
+      const result = uniq(array);
       expect(result).toStrictEqual(['a', 'b', 'c']);
     });
 
     test('should work with empty array', () => {
       const array: readonly number[] = [];
-      const result = Arr.uniq(array);
+      const result = uniq(array);
       expect(result).toStrictEqual([]);
     });
 
     test('should preserve order of first occurrence', () => {
       const array = [3, 1, 2, 1, 3, 2];
-      const result = Arr.uniq(array);
+      const result = uniq(array);
       expect(result).toStrictEqual([3, 1, 2]);
     });
   });
@@ -576,7 +382,7 @@ describe('Arr transformations', () => {
         { id: 1, name: 'Alice Duplicate' },
         { id: 3, name: 'Charlie' },
       ];
-      const result = Arr.uniqBy(array, (item) => item.id);
+      const result = uniqBy(array, (item) => item.id);
 
       expect(result).toHaveLength(3);
       expect(result[0]).toStrictEqual({ id: 1, name: 'Alice' });
@@ -586,7 +392,7 @@ describe('Arr transformations', () => {
 
     test('should work with string key function', () => {
       const words = ['hello', 'world', 'hi', 'welcome'];
-      const result = Arr.uniqBy(words, (word) => word.length);
+      const result = uniqBy(words, (word) => word.length);
 
       expect(result).toHaveLength(3);
       expect(result).toContain('hello'); // length 5
@@ -596,494 +402,43 @@ describe('Arr transformations', () => {
 
     test('should work with empty array', () => {
       const empty: readonly { id: number }[] = [];
-      const result = Arr.uniqBy(empty, (item) => item.id);
+      const result = uniqBy(empty, (item) => item.id);
       expect(result).toStrictEqual([]);
     });
   });
 
-  describe('map', () => {
-    const mapped = Arr.map([1, 2, 3], (x, i): number => x * x * i);
-
-    expectType<typeof mapped, ArrayOfLength<3, number>>('=');
-
-    test('case 1', () => {
-      expect(mapped).toStrictEqual([0, 4, 18]);
+  describe('flat', () => {
+    test('should flatten nested arrays with default depth 1', () => {
+      const nested = [
+        [1, 2],
+        [3, 4],
+        [5, 6],
+      ];
+      const flattened = flat(nested);
+      expect(flattened).toStrictEqual([1, 2, 3, 4, 5, 6]);
     });
 
-    test('should work with empty tuple', () => {
-      const empty = [] as const;
-      const mappedEmpty = Arr.map(empty, (x) => String(x));
-      expectType<typeof mappedEmpty, readonly []>('=');
-      expect(mappedEmpty).toStrictEqual([]);
+    test('should flatten with specified depth', () => {
+      const deepNested = [1, [2, [3, 4]], 5];
+      const flat1 = flat(deepNested, 1);
+      const flat2 = flat(deepNested, 2);
+      expect(flat1).toStrictEqual([1, 2, [3, 4], 5]);
+      expect(flat2).toStrictEqual([1, 2, 3, 4, 5]);
     });
 
-    test('should preserve tuple length with different types', () => {
-      const mixed = [1, 'hello', true] as const;
-      const mappedMixed = Arr.map(mixed, (x) => typeof x);
-      expectType<typeof mappedMixed, readonly [string, string, string]>('<=');
-      expect(mappedMixed).toStrictEqual(['number', 'string', 'boolean']);
+    test('should work with curried version', () => {
+      const flattenOnce = flat();
+      const result = flattenOnce([
+        [1, 2],
+        [3, 4],
+      ]);
+      expect(result).toStrictEqual([1, 2, 3, 4]);
     });
 
-    test('should work with index parameter', () => {
-      const tuple = ['a', 'b', 'c'] as const;
-      const mappedWithIndex = Arr.map(tuple, (x, i) => `${i}:${x}`);
-      expectType<typeof mappedWithIndex, readonly [string, string, string]>(
-        '<=',
-      );
-      expect(mappedWithIndex).toStrictEqual(['0:a', '1:b', '2:c']);
-    });
-  });
-
-  describe('toReversed', () => {
-    {
-      const xs = [1, 2, 3] as const;
-      const _nativeResult = xs.toReversed();
-
-      expectType<typeof _nativeResult, (1 | 2 | 3)[]>('=');
-
-      const result = Arr.toReversed([1, 2, 3]);
-
-      expectType<typeof result, readonly [3, 2, 1]>('=');
-
-      test('case 1', () => {
-        expect(result).toStrictEqual([3, 2, 1]);
-      });
-    }
-
-    test('should work with empty tuple', () => {
-      const empty = [] as const;
-      const reversed = Arr.toReversed(empty);
-      expectType<typeof reversed, readonly []>('=');
-      expect(reversed).toStrictEqual([]);
-    });
-
-    test('should work with single element', () => {
-      const single = [42] as const;
-      const reversed = Arr.toReversed(single);
-      expectType<typeof reversed, readonly [42]>('=');
-      expect(reversed).toStrictEqual([42]);
-    });
-
-    test('should preserve mixed types in reverse order', () => {
-      const mixed = [1, 'hello', true, null] as const;
-      const reversed = Arr.toReversed(mixed);
-      expectType<typeof reversed, readonly [null, true, 'hello', 1]>('=');
-      expect(reversed).toStrictEqual([null, true, 'hello', 1]);
-    });
-  });
-
-  describe('filter', () => {
-    test('should filter array with predicate', () => {
-      const numbers = [1, 2, 3, 4, 5];
-      const evens = Arr.filter(numbers, (n) => n % 2 === 0);
-      expect(evens).toStrictEqual([2, 4]);
-    });
-
-    test('should work with type guards', () => {
-      const mixed: (string | number | null)[] = [
-        'hello',
-        42,
-        null,
-        'world',
-        123,
-      ];
-      const strings = Arr.filter(
-        mixed,
-        (x): x is string => typeof x === 'string',
-      );
-      expectType<typeof strings, readonly string[]>('=');
-      expect(strings).toStrictEqual(['hello', 'world']);
-    });
-
-    test('should work with curried version', () => {
-      const isPositive = (n: number): boolean => n > 0;
-      const filterPositive = Arr.filter(isPositive);
-      const result = filterPositive([-1, 2, -3, 4]);
-      expect(result).toStrictEqual([2, 4]);
-    });
-
-    test('should work with curried type guards', () => {
-      const isString = (x: unknown): x is string => typeof x === 'string';
-      const filterStrings = Arr.filter(isString);
-      const result = filterStrings(['a', 1, 'b', 2]);
-      expectType<typeof result, readonly string[]>('=');
-      expect(result).toStrictEqual(['a', 'b']);
-    });
-
-    test('should preserve array type with generic predicate', () => {
-      const tuple = [1, 2, 3] as const;
-      const filtered = Arr.filter(tuple, (x) => x > 1);
-      expectType<typeof filtered, readonly (1 | 2 | 3)[]>('=');
-      expect(filtered).toStrictEqual([2, 3]);
-    });
-
-    test('should work with empty array', () => {
-      const empty: number[] = [];
-      const result = Arr.filter(empty, (n) => n > 0);
-      expect(result).toStrictEqual([]);
-    });
-
-    test('should pass index to predicate', () => {
-      const numbers = [10, 20, 30, 40];
-      const evenIndexes = Arr.filter(numbers, (_, i) => i % 2 === 0);
-      expect(evenIndexes).toStrictEqual([10, 30]);
-    });
-  });
-
-  describe('every', () => {
-    test('should return true when all elements satisfy predicate', () => {
-      const evens = [2, 4, 6, 8];
-      const allEven = Arr.every(evens, (n) => n % 2 === 0);
-      expect(allEven).toBe(true);
-    });
-
-    test('should return false when not all elements satisfy predicate', () => {
-      const mixed = [2, 3, 4, 6];
-      const allEven = Arr.every(mixed, (n) => n % 2 === 0);
-      expect(allEven).toBe(false);
-    });
-
-    test('should work as type guard', () => {
-      const mixed: (string | number)[] = ['hello', 'world'];
-      if (Arr.every(mixed, (x): x is string => typeof x === 'string')) {
-        // TypeScript narrows mixed to readonly string[] here
-        expect(mixed.every((s) => typeof s === 'string')).toBe(true);
-      }
-    });
-
-    test('should work with curried version', () => {
-      const isPositive = (n: number): boolean => n > 0;
-      const allPositive = Arr.every(isPositive);
-      expect(allPositive([1, 2, 3])).toBe(true);
-      expect(allPositive([1, -2, 3])).toBe(false);
-    });
-
-    test('should work with curried type guards', () => {
-      const isString = (x: unknown): x is string => typeof x === 'string';
-      const allStrings = Arr.every(isString);
-      const data: unknown[] = ['a', 'b', 'c'];
-      if (allStrings(data)) {
-        // TypeScript narrows data to readonly string[] here
-        expect(data.join('')).toBe('abc');
-      }
-    });
-
-    test('should return true for empty array', () => {
-      const empty: number[] = [];
-      const result = Arr.every(empty, (n) => n > 0);
-      expect(result).toBe(true);
-    });
-
-    test('should pass index to predicate', () => {
-      const numbers = [0, 1, 2, 3];
-      const indexMatchesValue = Arr.every(numbers, (val, idx) => val === idx);
-      expect(indexMatchesValue).toBe(true);
-    });
-  });
-
-  describe('some', () => {
-    test('should return true when at least one element satisfies predicate', () => {
-      const numbers = [1, 3, 5, 8];
-      const hasEven = Arr.some(numbers, (n) => n % 2 === 0);
-      expect(hasEven).toBe(true);
-    });
-
-    test('should return false when no elements satisfy predicate', () => {
-      const odds = [1, 3, 5, 7];
-      const hasEven = Arr.some(odds, (n) => n % 2 === 0);
-      expect(hasEven).toBe(false);
-    });
-
-    test('should work with curried version', () => {
-      const isNegative = (n: number): boolean => n < 0;
-      const hasNegative = Arr.some(isNegative);
-      expect(hasNegative([1, 2, -3])).toBe(true);
-      expect(hasNegative([1, 2, 3])).toBe(false);
-    });
-
-    test('should return false for empty array', () => {
-      const empty: number[] = [];
-      const result = Arr.some(empty, (n) => n > 0);
-      expect(result).toBe(false);
-    });
-
-    test('should pass index to predicate', () => {
-      const numbers = [10, 10, 10, 30];
-      const hasValueMatchingIndex = Arr.some(
-        numbers,
-        (val, idx) => val === idx * 10,
-      );
-      expect(hasValueMatchingIndex).toBe(true);
-    });
-  });
-
-  describe('entries', () => {
-    test('should return array of index-value pairs', () => {
-      const fruits = ['apple', 'banana', 'cherry'];
-      const entries = Array.from(Arr.entries(fruits));
-      expect(entries).toStrictEqual([
-        [0, 'apple'],
-        [1, 'banana'],
-        [2, 'cherry'],
-      ]);
-    });
-
-    test('should work with tuples', () => {
-      const tuple = [10, 20, 30] as const;
-      const entries = Array.from(Arr.entries(tuple));
-      expectType<typeof entries, (readonly [Uint32, 10 | 20 | 30])[]>('=');
-      expect(entries).toStrictEqual([
-        [0, 10],
-        [1, 20],
-        [2, 30],
-      ]);
-    });
-
-    test('should work with empty array', () => {
-      const empty: string[] = [];
-      const entries = Array.from(Arr.entries(empty));
-      expect(entries).toStrictEqual([]);
-    });
-
-    test('should preserve mixed types', () => {
-      const mixed = [1, 'hello', true] as const;
-      const entries = Array.from(Arr.entries(mixed));
-      expectType<typeof entries, (readonly [Uint32, 1 | 'hello' | true])[]>(
-        '=',
-      );
-      expect(entries).toStrictEqual([
-        [0, 1],
-        [1, 'hello'],
-        [2, true],
-      ]);
-    });
-  });
-
-  describe('values', () => {
-    test('should return copy of array values', () => {
-      const numbers = [1, 2, 3];
-      const values = Array.from(Arr.values(numbers));
-      expect(values).toStrictEqual([1, 2, 3]);
-      expect(values).not.toBe(numbers); // Should be a copy
-    });
-
-    test('should work with tuples', () => {
-      const tuple = ['a', 'b', 'c'] as const;
-      const values = Array.from(Arr.values(tuple));
-      expectType<typeof values, ('a' | 'b' | 'c')[]>('=');
-      expect(values).toStrictEqual(['a', 'b', 'c']);
-    });
-
-    test('should work with empty array', () => {
-      const empty: number[] = [];
-      const values = Array.from(Arr.values(empty));
-      expect(values).toStrictEqual([]);
-    });
-
-    test('should preserve mixed types', () => {
-      const mixed = [1, 'hello', null] as const;
-      const values = Array.from(Arr.values(mixed));
-      expectType<typeof values, (1 | 'hello' | null)[]>('=');
-      expect(values).toStrictEqual([1, 'hello', null]);
-    });
-  });
-
-  describe('indices', () => {
-    test('should return array of indices', () => {
-      const fruits = ['apple', 'banana', 'cherry'];
-      const indices = Array.from(Arr.indices(fruits));
-      expect(indices).toStrictEqual([0, 1, 2]);
-    });
-
-    test('should work with tuples', () => {
-      const tuple = ['a', 'b'] as const;
-      const indices = Array.from(Arr.indices(tuple));
-      expectType<typeof indices, Uint32[]>('=');
-      expect(indices).toStrictEqual([0, 1]);
-    });
-
-    test('should work with empty array', () => {
-      const empty: string[] = [];
-      const indices = Array.from(Arr.indices(empty));
-      expect(indices).toStrictEqual([]);
-    });
-
-    test('should work with larger arrays', () => {
-      const large = Array.from({ length: 5 }, () => 'x');
-      const indices = Array.from(Arr.indices(large));
-      expect(indices).toStrictEqual([0, 1, 2, 3, 4]);
-    });
-  });
-
-  describe('findLast', () => {
-    test('should find last element matching predicate', () => {
-      const numbers = [1, 2, 3, 4, 5];
-      const lastEven = Arr.findLast(numbers, (n) => n % 2 === 0);
-      expect(Optional.isSome(lastEven)).toBe(true);
-      expect(Optional.unwrap(lastEven)).toBe(4);
-    });
-
-    test('should return None when no element matches', () => {
-      const odds = [1, 3, 5];
-      const lastEven = Arr.findLast(odds, (n) => n % 2 === 0);
-      expect(Optional.isNone(lastEven)).toBe(true);
-    });
-
-    test('should work with curried version', () => {
-      const isPositive = (n: number): boolean => n > 0;
-      const findLastPositive = Arr.findLast(isPositive);
-      const result = findLastPositive([-1, 2, -3, 4]);
-      expect(Optional.isSome(result)).toBe(true);
-      expect(Optional.unwrap(result)).toBe(4);
-    });
-
-    test('should work with empty array', () => {
-      const empty: number[] = [];
-      const result = Arr.findLast(empty, (n) => n > 0);
-      expect(Optional.isNone(result)).toBe(true);
-    });
-
-    test('should pass index and array to predicate', () => {
-      const numbers = [10, 20, 30, 40];
-      const lastWithIndex2 = Arr.findLast(numbers, (_, idx, arr) => {
-        expect(arr).toBe(numbers);
-        return idx === 2;
-      });
-      expect(Optional.unwrap(lastWithIndex2)).toBe(30);
-    });
-
-    test('should find last occurrence', () => {
-      const numbers = [1, 2, 2, 3, 2, 4];
-      const lastTwo = Arr.findLast(numbers, (n) => n === 2);
-      expect(Optional.unwrap(lastTwo)).toBe(2);
-
-      // Verify it's actually the last occurrence by checking behavior
-      const index = numbers.lastIndexOf(2);
-      expect(index).toBe(4); // Last 2 is at index 4
-    });
-  });
-
-  describe('findLastIndex', () => {
-    test('should find last index matching predicate', () => {
-      const numbers = [1, 2, 3, 4, 2, 5];
-      const lastTwoIndex = Arr.findLastIndex(numbers, (n) => n === 2);
-      expect(lastTwoIndex).toBe(4);
-    });
-
-    test('should return -1 when no element matches', () => {
-      const odds = [1, 3, 5];
-      const lastEvenIndex = Arr.findLastIndex(odds, (n) => n % 2 === 0);
-      expect(lastEvenIndex).toBe(-1);
-    });
-
-    test('should work with curried version', () => {
-      const isPositive = (n: number): boolean => n > 0;
-      const findLastPositiveIndex = Arr.findLastIndex(isPositive);
-      const result = findLastPositiveIndex([-1, 2, -3, 4, -5]);
-      expect(result).toBe(3); // index of last positive number (4)
-    });
-
-    test('should work with empty array', () => {
-      const empty: number[] = [];
-      const result = Arr.findLastIndex(empty, (n) => n > 0);
-      expect(result).toBe(-1);
-    });
-
-    test('should pass index and array to predicate', () => {
-      const numbers = [10, 20, 30, 40];
-      const lastWithIndex2OrHigher = Arr.findLastIndex(
-        numbers,
-        (_, idx, arr) => {
-          expect(arr).toBe(numbers);
-          return idx >= 2;
-        },
-      );
-      expect(lastWithIndex2OrHigher).toBe(3); // last index >= 2
-    });
-
-    test('should find last occurrence with complex conditions', () => {
-      const data = [
-        { id: 1, active: true },
-        { id: 2, active: false },
-        { id: 3, active: true },
-        { id: 4, active: false },
-        { id: 5, active: true },
-      ];
-      const lastActiveIndex = Arr.findLastIndex(data, (item) => item.active);
-      expect(lastActiveIndex).toBe(4); // last active item
-    });
-
-    test('should work with tuples', () => {
-      const tuple = [10, 20, 30, 20, 40] as const;
-      const lastTwentyIndex = Arr.findLastIndex(tuple, (x) => x === 20);
-      expect(lastTwentyIndex).toBe(3); // last occurrence of 20
-    });
-
-    test('should search from end to beginning', () => {
-      // Verify search order by using side effects
-      const numbers = [1, 2, 3, 4, 5];
-      const mut_searchOrder: number[] = [];
-
-      Arr.findLastIndex(numbers, (val, idx) => {
-        mut_searchOrder.push(idx);
-        return val === 3;
-      });
-
-      // Should search from end: 4, 3, 2 (stops at 2 when found)
-      expect(mut_searchOrder).toStrictEqual([4, 3, 2]);
-    });
-
-    test('should handle single element array', () => {
-      const single = [42];
-      const foundIndex = Arr.findLastIndex(single, (n) => n === 42);
-      const notFoundIndex = Arr.findLastIndex(single, (n) => n === 0);
-
-      expect(foundIndex).toBe(0);
-      expect(notFoundIndex).toBe(-1);
-    });
-
-    test('should work with string arrays', () => {
-      const words = ['hello', 'world', 'test', 'hello', 'end'];
-      const lastHelloIndex = Arr.findLastIndex(
-        words,
-        (word) => word === 'hello',
-      );
-      expect(lastHelloIndex).toBe(3);
-    });
-  });
-
-  describe('flat', () => {
-    test('should flatten nested arrays with default depth 1', () => {
-      const nested = [
-        [1, 2],
-        [3, 4],
-        [5, 6],
-      ];
-      const flattened = Arr.flat(nested);
-      expect(flattened).toStrictEqual([1, 2, 3, 4, 5, 6]);
-    });
-
-    test('should flatten with specified depth', () => {
-      const deepNested = [1, [2, [3, 4]], 5];
-      const flat1 = Arr.flat(deepNested, 1);
-      const flat2 = Arr.flat(deepNested, 2);
-      expect(flat1).toStrictEqual([1, 2, [3, 4], 5]);
-      expect(flat2).toStrictEqual([1, 2, 3, 4, 5]);
-    });
-
-    test('should work with curried version', () => {
-      const flattenOnce = Arr.flat(1);
-      const result = flattenOnce([
-        [1, 2],
-        [3, 4],
-      ]);
-      expect(result).toStrictEqual([1, 2, 3, 4]);
-    });
-
-    test('should work with empty arrays', () => {
-      const withEmpties = [[1], [], [2, 3]];
-      const flattened = Arr.flat(withEmpties);
-      expect(flattened).toStrictEqual([1, 2, 3]);
+    test('should work with empty arrays', () => {
+      const withEmpties = [[1], [], [2, 3]];
+      const flattened = flat(withEmpties);
+      expect(flattened).toStrictEqual([1, 2, 3]);
     });
 
     test('should work with depth 0', () => {
@@ -1091,7 +446,7 @@ describe('Arr transformations', () => {
         [1, 2],
         [3, 4],
       ];
-      const unflattened = Arr.flat(nested, 0);
+      const unflattened = flat(nested, 0);
       expect(unflattened).toStrictEqual([
         [1, 2],
         [3, 4],
@@ -1100,7 +455,7 @@ describe('Arr transformations', () => {
 
     test('should work with infinite depth', () => {
       const veryDeep = [1, [2, [3, [4, [5]]]]];
-      const allFlat = Arr.flat(veryDeep, SafeUint.MAX_VALUE);
+      const allFlat = flat(veryDeep, SafeUint.MAX_VALUE);
       expect(allFlat).toStrictEqual([1, 2, 3, 4, 5]);
     });
   });
@@ -1108,7 +463,7 @@ describe('Arr transformations', () => {
   describe('flatMap', () => {
     test('should map and flatten results', () => {
       const words = ['hello', 'world'];
-      const chars = Arr.flatMap(words, (word) => word.split(''));
+      const chars = flatMap(words, (word) => word.split(''));
       expect(chars).toStrictEqual([
         'h',
         'e',
@@ -1124,39 +479,457 @@ describe('Arr transformations', () => {
     });
 
     test('should work with curried version', () => {
-      const splitWords = Arr.flatMap((word: string) => word.split(''));
+      const splitWords = flatMap((word: string) => word.split(''));
       const result = splitWords(['foo', 'bar']);
       expect(result).toStrictEqual(['f', 'o', 'o', 'b', 'a', 'r']);
     });
 
     test('should work with numbers', () => {
       const numbers = [1, 2, 3];
-      const doubled = Arr.flatMap(numbers, (n) => [n, n * 2]);
+      const doubled = flatMap(numbers, (n) => [n, n * 2]);
       expect(doubled).toStrictEqual([1, 2, 2, 4, 3, 6]);
     });
 
     test('should pass index to mapping function', () => {
       const numbers = [10, 20];
-      const result = Arr.flatMap(numbers, (n, i) => [n, i]);
+      const result = flatMap(numbers, (n, i) => [n, i]);
       expect(result).toStrictEqual([10, 0, 20, 1]);
     });
 
     test('should work with empty arrays', () => {
       const empty: string[] = [];
-      const result = Arr.flatMap(empty, (s) => s.split(''));
+      const result = flatMap(empty, (s) => s.split(''));
       expect(result).toStrictEqual([]);
     });
 
     test('should handle mapping to empty arrays', () => {
       const numbers = [1, 2, 3];
-      const result = Arr.flatMap(numbers, (n) => (n % 2 === 0 ? [n] : []));
+      const result = flatMap(numbers, (n) => (n % 2 === 0 ? [n] : []));
       expect(result).toStrictEqual([2]);
     });
 
     test('should work with tuples', () => {
       const tuple = [1, 2] as const;
-      const result = Arr.flatMap(tuple, (n) => [n, n]);
+      const result = flatMap(tuple, (n) => [n, n]);
       expect(result).toStrictEqual([1, 1, 2, 2]);
     });
   });
+
+  describe('partition', () => {
+    const xs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] as const;
+
+    {
+      const result = partition(xs, 4);
+
+      expectType<
+        typeof result,
+        readonly (readonly (
+          | 1
+          | 2
+          | 3
+          | 4
+          | 5
+          | 6
+          | 7
+          | 8
+          | 9
+          | 10
+          | 11
+          | 12
+        )[])[]
+      >('=');
+
+      test('case 1', () => {
+        expect(result).toStrictEqual([
+          [1, 2, 3, 4],
+          [5, 6, 7, 8],
+          [9, 10, 11, 12],
+        ]);
+      });
+    }
+
+    {
+      const result = partition(xs, 3);
+
+      expectType<
+        typeof result,
+        readonly (readonly (
+          | 1
+          | 2
+          | 3
+          | 4
+          | 5
+          | 6
+          | 7
+          | 8
+          | 9
+          | 10
+          | 11
+          | 12
+        )[])[]
+      >('=');
+
+      test('case 2', () => {
+        expect(result).toStrictEqual([
+          [1, 2, 3],
+          [4, 5, 6],
+          [7, 8, 9],
+          [10, 11, 12],
+        ]);
+      });
+    }
+
+    {
+      const result = partition(xs, 5);
+
+      expectType<
+        typeof result,
+        readonly (readonly (
+          | 1
+          | 2
+          | 3
+          | 4
+          | 5
+          | 6
+          | 7
+          | 8
+          | 9
+          | 10
+          | 11
+          | 12
+        )[])[]
+      >('=');
+
+      test('case 3', () => {
+        expect(result).toStrictEqual([
+          [1, 2, 3, 4, 5],
+          [6, 7, 8, 9, 10],
+          [11, 12],
+        ]);
+      });
+    }
+
+    test('should partition array into chunks', () => {
+      const numbers = [1, 2, 3, 4, 5, 6];
+      const result = partition(numbers, 2);
+
+      expect(result).toStrictEqual([
+        [1, 2],
+        [3, 4],
+        [5, 6],
+      ]);
+    });
+
+    test('should handle arrays not evenly divisible by chunk size', () => {
+      const numbers = [1, 2, 3, 4, 5];
+      const result = partition(numbers, 2);
+
+      expect(result).toStrictEqual([[1, 2], [3, 4], [5]]);
+    });
+
+    test('should work with chunk size < 2 (returns empty)', () => {
+      const numbers = [1, 2, 3];
+      const result = partition(numbers, 1);
+
+      // According to docs, returns empty array if chunkSize < 2
+      expect(result).toStrictEqual([]);
+    });
+
+    test('should work with chunk size larger than array', () => {
+      const numbers = [1, 2];
+      const result = partition(numbers, 5);
+
+      expect(result).toStrictEqual([[1, 2]]);
+    });
+
+    test('partition should work with empty array', () => {
+      const empty: readonly number[] = [];
+      const result = partition(empty, 2);
+
+      expect(result).toStrictEqual([]);
+    });
+  });
+
+  describe('concat', () => {
+    const xs = [1, 2, 3] as const;
+    const ys = [4, 5] as const;
+    const result = concat(xs, ys);
+
+    expectType<typeof result, readonly [1, 2, 3, 4, 5]>('=');
+
+    test('case 1', () => {
+      expect(result).toStrictEqual([1, 2, 3, 4, 5]);
+    });
+
+    // testArrayEquality({
+    //   testName: 'concat 2 arrays',
+    //   target: concat([1, 2, 3], [4, 5, 6]),
+    //   toBe: [1, 2, 3, 4, 5, 6],
+    // });
+
+    // testArrayEquality({
+    //   testName: 'concat 2 arrays',
+    //   target: concat([1, 2, 3], []),
+    //   toBe: [1, 2, 3],
+    // });
+
+    // testArrayEquality({
+    //   testName: 'concat 2 arrays',
+    //   target: concat([], [4, 5, 6]),
+    //   toBe: [4, 5, 6],
+    // });
+
+    // testArrayEquality({
+    //   testName: 'concat 2 arrays',
+    //   target: concat([], []),
+    //   toBe: [],
+    // });
+
+    // testArrayEquality({
+    //   testName: 'concat 2 arrays',
+    //   target: concat(['1', '2', '3'], [4, 5, 6]),
+    //   toBe: ['1', '2', '3', 4, 5, 6],
+    // });
+  });
+
+  describe('groupBy', () => {
+    const xs = [
+      { x: 1, y: 1 },
+      { x: 2, y: 1 },
+      { x: 3, y: 1 },
+      { x: 1, y: 2 },
+      { x: 2, y: 2 },
+      { x: 1, y: 3 },
+    ] as const;
+
+    const result = groupBy(xs, (a) => a.x);
+
+    expectType<
+      typeof result,
+      IMap<
+        1 | 2 | 3,
+        readonly (
+          | Readonly<{ x: 1; y: 1 }>
+          | Readonly<{ x: 1; y: 2 }>
+          | Readonly<{ x: 1; y: 3 }>
+          | Readonly<{ x: 2; y: 1 }>
+          | Readonly<{ x: 2; y: 2 }>
+          | Readonly<{ x: 3; y: 1 }>
+        )[]
+      >
+    >('=');
+
+    test('case 1', () => {
+      expect(result).toStrictEqual(
+        IMap.create<
+          1 | 2 | 3,
+          readonly (
+            | Readonly<{ x: 1; y: 1 }>
+            | Readonly<{ x: 1; y: 2 }>
+            | Readonly<{ x: 1; y: 3 }>
+            | Readonly<{ x: 2; y: 1 }>
+            | Readonly<{ x: 2; y: 2 }>
+            | Readonly<{ x: 3; y: 1 }>
+          )[]
+        >([
+          [
+            1,
+            [
+              { x: 1, y: 1 },
+              { x: 1, y: 2 },
+              { x: 1, y: 3 },
+            ],
+          ],
+          [
+            2,
+            [
+              { x: 2, y: 1 },
+              { x: 2, y: 2 },
+            ],
+          ],
+          [3, [{ x: 3, y: 1 }]],
+        ]),
+      );
+    });
+
+    test('should group elements by key', () => {
+      const array = [
+        { type: 'fruit', name: 'apple' },
+        { type: 'vegetable', name: 'carrot' },
+        { type: 'fruit', name: 'banana' },
+      ];
+      const grouped = groupBy(array, (item) => item.type);
+
+      expect(grouped.size).toBe(2);
+      const fruits = grouped.get('fruit');
+      const vegetables = grouped.get('vegetable');
+
+      expect(Optional.isSome(fruits)).toBe(true);
+      expect(Optional.isSome(vegetables)).toBe(true);
+
+      if (Optional.isSome(fruits)) {
+        expect(fruits.value).toHaveLength(2);
+        expect(fruits.value[0]?.name).toBe('apple');
+        expect(fruits.value[1]?.name).toBe('banana');
+      }
+
+      if (Optional.isSome(vegetables)) {
+        expect(vegetables.value).toHaveLength(1);
+        expect(vegetables.value[0]?.name).toBe('carrot');
+      }
+    });
+
+    test('should work with numeric keys', () => {
+      const numbers = [1, 2, 3, 4, 5, 6];
+      const grouped = groupBy(numbers, (n) => n % 2);
+
+      expect(grouped.size).toBe(2);
+      const evens = grouped.get(0);
+      const odds = grouped.get(1);
+
+      if (Optional.isSome(evens)) {
+        expect(evens.value).toStrictEqual([2, 4, 6]);
+      }
+
+      if (Optional.isSome(odds)) {
+        expect(odds.value).toStrictEqual([1, 3, 5]);
+      }
+    });
+
+    test('should work with empty array', () => {
+      const empty: readonly number[] = [];
+      const grouped = groupBy(empty, (n) => n % 2);
+      expect(grouped.size).toBe(0);
+    });
+
+    test('should handle all elements in same group', () => {
+      const array = [1, 2, 3, 4];
+      const grouped = groupBy(array, () => 'all');
+
+      expect(grouped.size).toBe(1);
+      const all = grouped.get('all');
+
+      if (Optional.isSome(all)) {
+        expect(all.value).toStrictEqual([1, 2, 3, 4]);
+      }
+    });
+  });
+
+  describe('zip', () => {
+    {
+      const xs = [1, 2, 3] as const;
+      const ys = [4, 5, 6] as const;
+      const zipped = zip(xs, ys);
+
+      expectType<
+        typeof zipped,
+        readonly [readonly [1, 4], readonly [2, 5], readonly [3, 6]]
+      >('=');
+
+      test('case 1', () => {
+        expect(zipped).toStrictEqual([
+          [1, 4],
+          [2, 5],
+          [3, 6],
+        ]);
+      });
+    }
+    {
+      const xs: readonly number[] = [1, 2, 3];
+      const ys: readonly number[] = [4];
+      const zipped = zip(xs, ys);
+
+      expectType<typeof zipped, readonly (readonly [number, number])[]>('=');
+
+      test('case 2', () => {
+        expect(zipped).toStrictEqual([[1, 4]]);
+      });
+    }
+    {
+      const xs = [1] as const;
+      const ys: readonly number[] = [4, 5, 6];
+      const zipped = zip(xs, ys);
+
+      expectType<typeof zipped, readonly [readonly [1, number]]>('=');
+
+      test('case 3', () => {
+        expect(zipped).toStrictEqual([[1, 4]]);
+      });
+    }
+
+    // testArrayEquality({
+    //   testName: 'zip',
+    //   target: zip([0, 1, 2, 3, 4], [5, 6, 7, 8, 9]),
+    //   toBe: [
+    //     [0, 5],
+    //     [1, 6],
+    //     [2, 7],
+    //     [3, 8],
+    //     [4, 9],
+    //   ],
+    // });
+
+    // testArrayEquality({
+    //   testName: 'zipArrays 2 arrays',
+    //   target: zipArrays([0, 1, 2, 3, 4], [5, 6, 7, 8, 9]),
+    //   toBe: [
+    //     [0, 5],
+    //     [1, 6],
+    //     [2, 7],
+    //     [3, 8],
+    //     [4, 9],
+    //   ],
+    // });
+
+    // testArrayEquality({
+    //   testName: 'zipArrays 3 arrays',
+    //   target: zipArrays(
+    //     [0, 1, 2, 3, 4],
+    //     [5, 6, 7, 8, 9, 999, 999],
+    //     [10, 11, 12, 13, 14, 999]
+    //   ),
+    //   toBe: [
+    //     [0, 5, 10],
+    //     [1, 6, 11],
+    //     [2, 7, 12],
+    //     [3, 8, 13],
+    //     [4, 9, 14],
+    //   ],
+    // });
+
+    test('should zip two arrays', () => {
+      const arr1 = [1, 2, 3];
+      const arr2 = ['a', 'b', 'c'];
+      const result = zip(arr1, arr2);
+      expect(result).toStrictEqual([
+        [1, 'a'],
+        [2, 'b'],
+        [3, 'c'],
+      ]);
+    });
+
+    test('should handle arrays of different lengths', () => {
+      const arr1 = [1, 2, 3, 4];
+      const arr2 = ['a', 'b'];
+      const result = zip(arr1, arr2);
+      expect(result).toStrictEqual([
+        [1, 'a'],
+        [2, 'b'],
+      ]);
+    });
+
+    test('should work with empty arrays', () => {
+      const arr1: readonly number[] = [];
+      const arr2: readonly string[] = [];
+      const result = zip(arr1, arr2);
+      expect(result).toStrictEqual([]);
+    });
+
+    test('should handle one empty array', () => {
+      const arr1 = [1, 2, 3];
+      const arr2: readonly string[] = [];
+      const result = zip(arr1, arr2);
+      expect(result).toStrictEqual([]);
+    });
+  });
 });