ts-data-forge 14.9.0 → 14.10.1

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

@@ -70,38 +70,6 @@ export function find<E>(
   }
 }
 
-const findImpl = <E,>(
-  array: readonly E[],
-  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
-): Optional<E> => {
-  const foundIndex = array.findIndex(
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    predicate as () => boolean,
-  );
-
-  // Left as a comment rather than asserted. This pinned the shape of the
-  // standard library's `findIndex`, and the shape differs between the stock
-  // library and the strict one — `(value, index, obj: this) => boolean` there
-  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships
-  // to consumers so that "Go to Definition" reaches it, so an assertion that
-  // only holds under one of them shows up as an error in their editor.
-  //
-  // expectType<
-  //   Parameters<typeof array.findIndex>[0],
-  //   (value: E, index: number, arr: readonly E[]) => unknown
-  // >('=');
-
-  expectType<
-    typeof predicate,
-    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-  >('=');
-
-  return foundIndex === -1
-    ? Optional.none
-    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      Optional.some(array[foundIndex]!);
-};
-
 /**
  * Finds the last element that satisfies a predicate.
  *
@@ -160,38 +128,6 @@ export function findLast<E>(
   }
 }
 
-const findLastImpl = <E,>(
-  array: readonly E[],
-  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
-): Optional<E> => {
-  const foundIndex = array.findLastIndex(
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    predicate as () => boolean,
-  );
-
-  // Left as a comment rather than asserted. This pinned the shape of the
-  // standard library's `findIndex`, and the shape differs between the stock
-  // library and the strict one — `(value, index, obj: this) => boolean` there
-  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships
-  // to consumers so that "Go to Definition" reaches it, so an assertion that
-  // only holds under one of them shows up as an error in their editor.
-  //
-  // expectType<
-  //   Parameters<typeof array.findIndex>[0],
-  //   (value: E, index: number, arr: readonly E[]) => unknown
-  // >('=');
-
-  expectType<
-    typeof predicate,
-    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-  >('=');
-
-  return foundIndex === -1
-    ? Optional.none
-    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      Optional.some(array[foundIndex]!);
-};
-
 /**
  * Finds the index of the first element that satisfies a predicate.
  *
@@ -247,17 +183,6 @@ export function findIndex<E>(
   }
 }
 
-const findIndexImpl = <E,>(
-  array: readonly E[],
-  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
-): SizeType.Arr | -1 =>
-  pipe(
-    array.findIndex(
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      predicate as (value: E, index: number) => boolean,
-    ),
-  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
-
 /**
  * Finds the index of the last element that satisfies a predicate.
  *
@@ -313,17 +238,6 @@ export function findLastIndex<E>(
   }
 }
 
-const findLastIndexImpl = <E,>(
-  array: readonly E[],
-  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
-): SizeType.Arr | -1 =>
-  pipe(
-    array.findLastIndex(
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      predicate as (value: E, index: number) => boolean,
-    ),
-  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
-
 /**
  * Gets the index of a value in an array.
  *
@@ -371,15 +285,6 @@ export function indexOf<E>(
   }
 }
 
-const indexOfImpl = <E,>(
-  array: readonly E[],
-  searchElement: E,
-): SizeType.Arr | -1 => {
-  const index = array.indexOf(searchElement);
-
-  return index !== -1 ? asUint32(index) : -1;
-};
-
 /**
  * Gets the index of a value in an array, starting from a specified index.
  *
@@ -440,16 +345,6 @@ export function indexOfFrom<E>(
   }
 }
 
-const indexOfFromImpl = <E,>(
-  array: readonly E[],
-  searchElement: E,
-  fromIndex: SizeType.ArgArrWithNegative,
-): SizeType.Arr | -1 => {
-  const index = array.indexOf(searchElement, fromIndex);
-
-  return index !== -1 ? asUint32(index) : -1;
-};
-
 /**
  * Gets the last index of a value in an array.
  *
@@ -501,15 +396,6 @@ export function lastIndexOf<E>(
   }
 }
 
-const lastIndexOfImpl = <E,>(
-  array: readonly E[],
-  searchElement: E,
-): SizeType.Arr | -1 => {
-  const index = array.lastIndexOf(searchElement);
-
-  return index !== -1 ? asUint32(index) : -1;
-};
-
 /**
  * Gets the last index of a value in an array, starting from a specified index.
  *
@@ -570,6 +456,120 @@ export function lastIndexOfFrom<E>(
   }
 }
 
+const findImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): Optional<E> => {
+  const foundIndex = array.findIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate as () => boolean,
+  );
+
+  // Left as a comment rather than asserted. This pinned the shape of the
+  // standard library's `findIndex`, and the shape differs between the stock
+  // library and the strict one — `(value, index, obj: this) => boolean` there
+  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships to
+  // consumers so that "Go to Definition" reaches it, so an assertion that only
+  // holds under one of them shows up as an error in their editor.
+  //
+  // expectType<
+  //   Parameters<typeof array.findIndex>[0],
+  //   (value: E, index: number, arr: readonly E[]) => unknown
+  // >('=');
+
+  expectType<
+    typeof predicate,
+    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
+  >('=');
+
+  return foundIndex === -1
+    ? Optional.none
+    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      Optional.some(array[foundIndex]!);
+};
+
+const findLastImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): Optional<E> => {
+  const foundIndex = array.findLastIndex(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    predicate as () => boolean,
+  );
+
+  // Left as a comment rather than asserted. This pinned the shape of the
+  // standard library's `findIndex`, and the shape differs between the stock
+  // library and the strict one — `(value, index, obj: this) => boolean` there
+  // against `(value, index, arr: readonly E[]) => unknown` here. `src` ships to
+  // consumers so that "Go to Definition" reaches it, so an assertion that only
+  // holds under one of them shows up as an error in their editor.
+  //
+  // expectType<
+  //   Parameters<typeof array.findIndex>[0],
+  //   (value: E, index: number, arr: readonly E[]) => unknown
+  // >('=');
+
+  expectType<
+    typeof predicate,
+    (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
+  >('=');
+
+  return foundIndex === -1
+    ? Optional.none
+    : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      Optional.some(array[foundIndex]!);
+};
+
+const findIndexImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): SizeType.Arr | -1 =>
+  pipe(
+    array.findIndex(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      predicate as (value: E, index: number) => boolean,
+    ),
+  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
+
+const findLastIndexImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean,
+): SizeType.Arr | -1 =>
+  pipe(
+    array.findLastIndex(
+      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      predicate as (value: E, index: number) => boolean,
+    ),
+  ).map((idx) => (idx >= 0 ? asUint32(idx) : -1)).value;
+
+const indexOfImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+): SizeType.Arr | -1 => {
+  const index = array.indexOf(searchElement);
+
+  return index !== -1 ? asUint32(index) : -1;
+};
+
+const indexOfFromImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+  fromIndex: SizeType.ArgArrWithNegative,
+): SizeType.Arr | -1 => {
+  const index = array.indexOf(searchElement, fromIndex);
+
+  return index !== -1 ? asUint32(index) : -1;
+};
+
+const lastIndexOfImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+): SizeType.Arr | -1 => {
+  const index = array.lastIndexOf(searchElement);
+
+  return index !== -1 ? asUint32(index) : -1;
+};
+
 const lastIndexOfFromImpl = <E,>(
   array: readonly E[],
   searchElement: E,

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

@@ -131,11 +131,6 @@ export function take<E>(
   }
 }
 
-const takeImpl = <E,>(
-  array: readonly E[],
-  num: SizeType.ArgArr,
-): readonly E[] => sliceClamped(array, 0, num);
-
 /**
  * Takes the last N elements from an array.
  *
@@ -197,12 +192,6 @@ export function takeLast<E>(
   }
 }
 
-const takeLastImpl = <E,>(
-  array: readonly E[],
-  num: SizeType.ArgArr,
-): readonly E[] =>
-  sliceClamped(array, Uint32.sub(size(array), num), size(array));
-
 /**
  * Skips the first N elements of an array.
  *
@@ -255,11 +244,6 @@ export function skip<E>(
   }
 }
 
-const skipImpl = <E,>(
-  array: readonly E[],
-  num: SizeType.ArgArr,
-): readonly E[] => sliceClamped(array, num, size(array));
-
 /**
  * Skips the last N elements of an array.
  *
@@ -314,6 +298,22 @@ export function skipLast<E>(
   }
 }
 
+const takeImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, 0, num);
+
+const takeLastImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] =>
+  sliceClamped(array, Uint32.sub(size(array), num), size(array));
+
+const skipImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, num, size(array));
+
 const skipLastImpl = <E,>(
   array: readonly E[],
   num: SizeType.ArgArr,

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

@@ -48,8 +48,8 @@ export function map<const Ar extends readonly unknown[] & UnknownBrand, B>(
   mapFn: (a: Ar[number], index: ArrayIndex<Ar>) => B,
 ): ChangeArrayElement<Ar, B>;
 
-// A plain array or tuple carries no length brand, so the homomorphic mapping
-// is the whole answer. Stating it directly — rather than going through
+// A plain array or tuple carries no length brand, so the homomorphic mapping is
+// the whole answer. Stating it directly — rather than going through
 // `ChangeArrayElement`, whose `HasLengthConstraint` test a *generic* `Ar`
 // cannot decide — is what keeps `map` usable inside a function that is itself
 // generic over the tuple: a deferred conditional is not assignable to the
@@ -68,8 +68,8 @@ export function map<const Ar extends readonly unknown[], B>(
 //
 // Spelled as an intersection of two function types rather than one object type
 // carrying two call signatures — the `convert-to-readonly` codemod wraps an
-// inline object type in `Readonly<…>`, and a mapped type drops call
-// signatures, which would leave the curried form with none at all.
+// inline object type in `Readonly<…>`, and a mapped type drops call signatures,
+// which would leave the curried form with none at all.
 export function map<A, B>(
   mapFn: (a: A, index: SizeType.Arr) => B,
 ): (<const Ar extends readonly A[] & UnknownBrand>(
@@ -175,26 +175,6 @@ export function scan<E, S>(
   }
 }
 
-const scanImpl = <E, S>(
-  array: readonly E[],
-  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,
-  init: S,
-): NonEmptyTuple<S> => {
-  const mut_result = castMutable<NonEmptyTuple<S>>(
-    newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),
-  );
-
-  let mut_acc = init;
-
-  for (const [index, value] of array.entries()) {
-    mut_acc = reducer(mut_acc, value, asUint32(index));
-
-    mut_result[index + 1] = mut_acc;
-  }
-
-  return mut_result;
-};
-
 /**
  * Reverses an array.
  *
@@ -277,16 +257,6 @@ export function toSorted(
   );
 }
 
-/** The result of sorting `Ar`: same elements, same length, same bounds. */
-type SortedResult<Ar extends readonly unknown[]> =
-  HasLengthConstraint<Ar> extends true
-    ? ChangeArrayElement<Ar, Ar[number]>
-    : IsFixedLengthList<Ar> extends true
-      ? FixedLengthTuple<Ar['length'], Ar[number]>
-      : Ar extends NonEmptyTuple<unknown>
-        ? NonEmptyArray<Ar[number]>
-        : readonly Ar[number][];
-
 /**
  * Sorts an array by a mapped value.
  *
@@ -426,11 +396,6 @@ export function filter<E>(
   }
 }
 
-const filterImpl = <E,>(
-  array: readonly E[],
-  predicate: (a: E, index: SizeType.Arr) => boolean,
-): readonly E[] => array.filter((a, i) => predicate(a, asUint32(i)));
-
 /**
  * Filters an array by excluding elements for which the predicate returns true.
  *
@@ -474,11 +439,6 @@ export function filterNot<E>(
   }
 }
 
-const filterNotImpl = <E,>(
-  array: readonly E[],
-  predicate: (a: E, index: SizeType.Arr) => boolean,
-): readonly E[] => array.filter((a, i) => !predicate(a, asUint32(i)));
-
 /**
  * Creates a new array with unique elements.
  *
@@ -615,11 +575,6 @@ export function flat<E, D extends SafeUintWithSmallInt = 1>(
   }
 }
 
-const flatImpl = (
-  array: readonly unknown[],
-  depth?: SafeUintWithSmallInt,
-): readonly unknown[] => array.flat(depth);
-
 /**
  * Maps each element and flattens the result.
  *
@@ -734,37 +689,6 @@ export function partition<
   }
 }
 
-/**
- * Element type of {@link partition}'s result: a chunk holds between 1 and `N`
- * elements. The lower bound is what makes this worth spelling out — `partition`
- * never emits an empty chunk, so indexed access into a chunk is not
- * `undefined` at position `0`, unlike with a plain `readonly E[]`.
- *
- * Falls back to {@link NonEmptyArray} when `N` is not a bound the brand can
- * express, which keeps that lower bound in every case.
- */
-type PartitionChunk<N, E> = N extends SupportedLength
-  ? BoundedLengthArray<1, N, E>
-  : NonEmptyArray<E>;
-
-const partitionImpl = <E, N extends WithSmallInt<PositiveInt & SizeType.Arr>>(
-  array: readonly E[],
-  chunkSize: N,
-): readonly (readonly E[])[] =>
-  chunkSize < 2
-    ? ([] as const)
-    : // eslint-disable-next-line total-functions/no-partial-division
-      seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>
-        array.slice(chunkSize * i, chunkSize * (i + 1)),
-      );
-
-/**
- * Alias for `partition`.
- *
- * @see {@link partition}
- */
-export const chunk = partition;
-
 /**
  * Concatenates two arrays.
  *
@@ -805,22 +729,6 @@ export const concat = <
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   [...array1, ...array2] as never;
 
-/**
- * Return type of {@link concat}: the concatenated tuple `readonly [...Ar1,
- * ...Ar2]`, additionally branded as {@link NonEmptyArray} when either input is
- * a non-empty tuple (a plain non-empty tuple or a branded `NonEmptyArray`,
- * both of which extend `NonEmptyTuple<unknown>`).
- */
-type ConcatResult<
-  Ar1 extends readonly unknown[],
-  Ar2 extends readonly unknown[],
-> =
-  Ar1 extends NonEmptyTuple<unknown>
-    ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>
-    : Ar2 extends NonEmptyTuple<unknown>
-      ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>
-      : readonly [...Ar1, ...Ar2];
-
 /**
  * Groups elements by a key derived from each element.
  *
@@ -985,3 +893,95 @@ export const cartesianProduct = <T,>(
 
   return first.flatMap((item) => restProduct.map((prod) => [item, ...prod]));
 };
+
+const scanImpl = <E, S>(
+  array: readonly E[],
+  reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S,
+  init: S,
+): NonEmptyTuple<S> => {
+  const mut_result = castMutable<NonEmptyTuple<S>>(
+    newArray<PositiveUint32, S>(asPositiveUint32(array.length + 1), init),
+  );
+
+  let mut_acc = init;
+
+  for (const [index, value] of array.entries()) {
+    mut_acc = reducer(mut_acc, value, asUint32(index));
+
+    mut_result[index + 1] = mut_acc;
+  }
+
+  return mut_result;
+};
+
+/** The result of sorting `Ar`: same elements, same length, same bounds. */
+type SortedResult<Ar extends readonly unknown[]> =
+  HasLengthConstraint<Ar> extends true
+    ? ChangeArrayElement<Ar, Ar[number]>
+    : IsFixedLengthList<Ar> extends true
+      ? FixedLengthTuple<Ar['length'], Ar[number]>
+      : Ar extends NonEmptyTuple<unknown>
+        ? NonEmptyArray<Ar[number]>
+        : readonly Ar[number][];
+
+const filterImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): readonly E[] => array.filter((a, i) => predicate(a, asUint32(i)));
+
+const filterNotImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): readonly E[] => array.filter((a, i) => !predicate(a, asUint32(i)));
+
+const flatImpl = (
+  array: readonly unknown[],
+  depth?: SafeUintWithSmallInt,
+): readonly unknown[] => array.flat(depth);
+
+/**
+ * Element type of {@link partition}'s result: a chunk holds between 1 and `N`
+ * elements. The lower bound is what makes this worth spelling out — `partition`
+ * never emits an empty chunk, so indexed access into a chunk is not `undefined`
+ * at position `0`, unlike with a plain `readonly E[]`.
+ *
+ * Falls back to {@link NonEmptyArray} when `N` is not a bound the brand can
+ * express, which keeps that lower bound in every case.
+ */
+type PartitionChunk<N, E> = N extends SupportedLength
+  ? BoundedLengthArray<1, N, E>
+  : NonEmptyArray<E>;
+
+const partitionImpl = <E, N extends WithSmallInt<PositiveInt & SizeType.Arr>>(
+  array: readonly E[],
+  chunkSize: N,
+): readonly (readonly E[])[] =>
+  chunkSize < 2
+    ? ([] as const)
+    : // eslint-disable-next-line total-functions/no-partial-division
+      seq(asUint32(Math.ceil(array.length / chunkSize))).map((i: Uint32) =>
+        array.slice(chunkSize * i, chunkSize * (i + 1)),
+      );
+
+/**
+ * Alias for `partition`.
+ *
+ * @see {@link partition}
+ */
+export const chunk = partition;
+
+/**
+ * Return type of {@link concat}: the concatenated tuple `readonly [...Ar1,
+ * ...Ar2]`, additionally branded as {@link NonEmptyArray} when either input is
+ * a non-empty tuple (a plain non-empty tuple or a branded `NonEmptyArray`, both
+ * of which extend `NonEmptyTuple<unknown>`).
+ */
+type ConcatResult<
+  Ar1 extends readonly unknown[],
+  Ar2 extends readonly unknown[],
+> =
+  Ar1 extends NonEmptyTuple<unknown>
+    ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>
+    : Ar2 extends NonEmptyTuple<unknown>
+      ? readonly [...Ar1, ...Ar2] & NonEmptyArray<Ar1[number] | Ar2[number]>
+      : readonly [...Ar1, ...Ar2];

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

@@ -71,8 +71,8 @@ describe('Arr transformations', () => {
 
     test('should preserve the tuple shape under a generic parameter', () => {
       // A caller that is itself generic over the tuple cannot resolve a
-      // conditional return type, so `map` has to report the homomorphic
-      // mapping directly for a parameter that carries no length brand.
+      // conditional return type, so `map` has to report the homomorphic mapping
+      // directly for a parameter that carries no length brand.
       const mapValues = <const T extends readonly Readonly<{ v: unknown }>[]>(
         boxes: T,
       ): Readonly<{ [K in keyof T]: unknown }> => map(boxes, (b) => b.v);

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

@@ -63,11 +63,11 @@ type Cast<A, B> = A extends B ? A : never;
  */
 // Type guard overloads - narrow the entire array type.
 //
-// Both narrowed types are intersected with `Ar`: a type predicate's type has
-// to be assignable to the parameter's type, and neither the deferred
-// conditional `ChangeArrayElement<Ar, S>` nor the mapped type over a generic
-// `Ar` is (TS2677). The intersection also keeps whatever the caller already
-// knew about the array — a branded five-tuple stays a five-tuple.
+// Both narrowed types are intersected with `Ar`: a type predicate's type has to
+// be assignable to the parameter's type, and neither the deferred conditional
+// `ChangeArrayElement<Ar, S>` nor the mapped type over a generic `Ar` is
+// (TS2677). The intersection also keeps whatever the caller already knew about
+// the array — a branded five-tuple stays a five-tuple.
 export function every<
   const Ar extends readonly unknown[] & UnknownBrand,
   S extends Ar[number],
@@ -76,8 +76,8 @@ export function every<
   predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,
 ): array is ChangeArrayElement<Ar, S> & Ar;
 
-// A plain array or tuple carries no length brand, so the homomorphic mapping
-// is the whole answer — same reasoning as in `map`.
+// A plain array or tuple carries no length brand, so the homomorphic mapping is
+// the whole answer — same reasoning as in `map`.
 export function every<
   const Ar extends readonly unknown[],
   S extends Ar[number],
@@ -98,8 +98,8 @@ export function every<const Ar extends readonly unknown[]>(
 // returned function*, not two overloads of `every` itself: both curried
 // signatures take the same single predicate, so overload resolution would
 // always pick the first and the second would be dead — which is what left a
-// plain `readonly unknown[]` unable to satisfy the `UnknownBrand` constraint
-// at the call site of the returned guard.
+// plain `readonly unknown[]` unable to satisfy the `UnknownBrand` constraint at
+// the call site of the returned guard.
 //
 // The intersection is also what keeps the group compatible with the
 // implementation signature. A lone `<Ar extends readonly E[] & UnknownBrand>`
@@ -136,11 +136,6 @@ export function every<E>(
   }
 }
 
-const everyImpl = <E,>(
-  array: readonly E[],
-  predicate: (a: E, index: SizeType.Arr) => boolean,
-): boolean => array.every((a, i) => predicate(a, asUint32(i)));
-
 /**
  * Tests whether at least one element in an array passes a test implemented by a predicate.
  *
@@ -186,11 +181,6 @@ export function some<E>(
   }
 }
 
-const someImpl = <E,>(
-  array: readonly E[],
-  predicate: (a: E, index: SizeType.Arr) => boolean,
-): boolean => array.some((a, i) => predicate(a, asUint32(i)));
-
 /**
  * Checks if an index is within the valid range of an array.
  *
@@ -212,3 +202,13 @@ export const indexIsInRange = <E,>(
   array: readonly E[],
   index: SizeType.ArgArr,
 ): boolean => Num.isInRange(0, array.length)(index);
+
+const everyImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): boolean => array.every((a, i) => predicate(a, asUint32(i)));
+
+const someImpl = <E,>(
+  array: readonly E[],
+  predicate: (a: E, index: SizeType.Arr) => boolean,
+): boolean => array.some((a, i) => predicate(a, asUint32(i)));

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

@@ -39,7 +39,7 @@ describe('Arr validations', () => {
 
       assert.isFalse(isArray({}));
 
-      assert.isFalse(isArray(new Set()));
+      assert.isFalse(isArray(new Set<unknown>()));
     });
 
     test('should refine union types correctly', () => {