ts-data-forge 12.2.1 → 13.0.0

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

@@ -239,24 +239,24 @@ export function count<E>(
     | readonly [predicate: (value: E, index: SizeType.Arr) => boolean]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr) {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return array.reduce<Uint32>(
-        (acc, curr, index) =>
-          predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
-        asUint32(0),
-      );
-    }
+    case 2:
+      return countImpl(...args);
 
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => count(array, predicate);
-    }
+    case 1:
+      return (array) => countImpl(array, ...args);
   }
 }
 
+const countImpl = <E,>(
+  array: readonly E[],
+  predicate: (value: E, index: SizeType.Arr) => boolean,
+): SizeType.Arr =>
+  array.reduce<Uint32>(
+    (acc, curr, index) =>
+      predicate(curr, asUint32(index)) ? Uint32.add(acc, 1) : acc,
+    asUint32(0),
+  );
+
 /**
  * Groups elements by a key and counts the elements in each group.
  *
@@ -295,29 +295,30 @@ export function countBy<E, G extends MapSetKeyType>(
     | readonly [grouper: (value: E, index: SizeType.Arr) => G]
 ): IMap<G, SizeType.Arr> | ((array: readonly E[]) => IMap<G, SizeType.Arr>) {
   switch (args.length) {
-    case 2: {
-      const [array, grouper] = args;
-
-      const mut_groups = new Map<G, SizeType.Arr>();
-
-      for (const [index, e] of array.entries()) {
-        const key = grouper(e, asUint32(index));
+    case 2:
+      return countByImpl(...args);
 
-        const curr = mut_groups.get(key) ?? 0;
+    case 1:
+      return (array) => countByImpl(array, ...args);
+  }
+}
 
-        mut_groups.set(key, asUint32(curr + 1));
-      }
+const countByImpl = <E, G extends MapSetKeyType>(
+  array: readonly E[],
+  grouper: (value: E, index: SizeType.Arr) => G,
+): IMap<G, SizeType.Arr> => {
+  const mut_groups = new Map<G, SizeType.Arr>();
 
-      return IMap.create(mut_groups);
-    }
+  for (const [index, e] of array.entries()) {
+    const key = grouper(e, asUint32(index));
 
-    case 1: {
-      const [grouper] = args;
+    const curr = mut_groups.get(key) ?? 0;
 
-      return (array) => countBy(array, grouper);
-    }
+    mut_groups.set(key, asUint32(curr + 1));
   }
-}
+
+  return IMap.create(mut_groups);
+};
 
 /**
  * Reduces an array to a single value from left to right.
@@ -379,23 +380,28 @@ export function foldl<E, P>(
       ]
 ): P | ((array: readonly E[]) => P) {
   switch (args.length) {
-    case 3: {
-      const [array, callbackfn, initialValue] = args;
-
-      return array.reduce(
-        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
-        initialValue,
-      );
-    }
+    case 3:
+      return foldlImpl(...args);
 
-    case 2: {
-      const [callbackfn, initialValue] = args;
-
-      return (array) => foldl(array, callbackfn, initialValue);
-    }
+    case 2:
+      return (array) => foldlImpl(array, ...args);
   }
 }
 
+const foldlImpl = <E, P>(
+  array: readonly E[],
+  callbackfn: (
+    previousValue: P,
+    currentValue: E,
+    currentIndex: SizeType.Arr,
+  ) => P,
+  initialValue: P,
+): P =>
+  array.reduce(
+    (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+    initialValue,
+  );
+
 /**
  * Reduces an array to a single value from right to left.
  *
@@ -456,23 +462,28 @@ export function foldr<E, P>(
       ]
 ): P | ((array: readonly E[]) => P) {
   switch (args.length) {
-    case 3: {
-      const [array, callbackfn, initialValue] = args;
-
-      return array.reduceRight(
-        (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
-        initialValue,
-      );
-    }
-
-    case 2: {
-      const [callbackfn, initialValue] = args;
+    case 3:
+      return foldrImpl(...args);
 
-      return (array) => foldr(array, callbackfn, initialValue);
-    }
+    case 2:
+      return (array) => foldrImpl(array, ...args);
   }
 }
 
+const foldrImpl = <E, P>(
+  array: readonly E[],
+  callbackfn: (
+    previousValue: P,
+    currentValue: E,
+    currentIndex: SizeType.Arr,
+  ) => P,
+  initialValue: P,
+): P =>
+  array.reduceRight(
+    (prev, curr, index) => callbackfn(prev, curr, asUint32(index)),
+    initialValue,
+  );
+
 /**
  * Calculates the sum of numbers in an array.
  *

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

@@ -62,43 +62,39 @@ export function find<E>(
       ]
 ): Optional<E> | ((array: readonly E[]) => Optional<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,
-      );
-
-      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]!);
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      expectType<
-        typeof predicate,
-        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-      >('=');
-
-      return (array) => find(array, predicate);
-    }
+    case 2:
+      return findImpl(...args);
+
+    case 1:
+      return (array) => findImpl(array, ...args);
   }
 }
 
+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,
+  );
+
+  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.
  *
@@ -149,43 +145,39 @@ export function findLast<E>(
       ]
 ): Optional<E> | ((array: readonly E[]) => Optional<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,
-      );
-
-      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]!);
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      expectType<
-        typeof predicate,
-        (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean
-      >('=');
-
-      return (array) => findLast(array, predicate);
-    }
+    case 2:
+      return findLastImpl(...args);
+
+    case 1:
+      return (array) => findLastImpl(array, ...args);
   }
 }
 
+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,
+  );
+
+  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.
  *
@@ -233,25 +225,25 @@ export function findIndex<E>(
       ]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return 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;
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => findIndex(array, predicate);
-    }
+    case 2:
+      return findIndexImpl(...args);
+
+    case 1:
+      return (array) => findIndexImpl(array, ...args);
   }
 }
 
+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.
  *
@@ -299,25 +291,25 @@ export function findLastIndex<E>(
       ]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, predicate] = args;
-
-      return 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;
-    }
-
-    case 1: {
-      const [predicate] = args;
-
-      return (array) => findLastIndex(array, predicate);
-    }
+    case 2:
+      return findLastIndexImpl(...args);
+
+    case 1:
+      return (array) => findLastIndexImpl(array, ...args);
   }
 }
 
+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.
  *
@@ -357,22 +349,23 @@ export function indexOf<E>(
     | readonly [searchElement: E]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, searchElement] = args;
-
-      const index = array.indexOf(searchElement);
-
-      return index !== -1 ? asUint32(index) : -1;
-    }
+    case 2:
+      return indexOfImpl(...args);
 
-    case 1: {
-      const [searchElement] = args;
-
-      return (array) => indexOf(array, searchElement);
-    }
+    case 1:
+      return (array) => indexOfImpl(array, ...args);
   }
 }
 
+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.
  *
@@ -425,22 +418,24 @@ export function indexOfFrom<E>(
     | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 3: {
-      const [array, searchElement, fromIndex] = args;
+    case 3:
+      return indexOfFromImpl(...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);
-    }
+    case 2:
+      return (array) => indexOfFromImpl(array, ...args);
   }
 }
 
+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.
  *
@@ -484,22 +479,23 @@ export function lastIndexOf<E>(
     | readonly [searchElement: E]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 2: {
-      const [array, searchElement] = args;
-
-      const index = array.lastIndexOf(searchElement);
+    case 2:
+      return lastIndexOfImpl(...args);
 
-      return index !== -1 ? asUint32(index) : -1;
-    }
-
-    case 1: {
-      const [searchElement] = args;
-
-      return (array) => lastIndexOf(array, searchElement);
-    }
+    case 1:
+      return (array) => lastIndexOfImpl(array, ...args);
   }
 }
 
+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.
  *
@@ -552,18 +548,20 @@ export function lastIndexOfFrom<E>(
     | readonly [searchElement: E, fromIndex: SizeType.ArgArrWithNegative]
 ): SizeType.Arr | ((array: readonly E[]) => SizeType.Arr | -1) | -1 {
   switch (args.length) {
-    case 3: {
-      const [array, searchElement, fromIndex] = args;
-
-      const index = array.lastIndexOf(searchElement, fromIndex);
-
-      return index !== -1 ? asUint32(index) : -1;
-    }
-
-    case 2: {
-      const [searchElement, fromIndex] = args;
+    case 3:
+      return lastIndexOfFromImpl(...args);
 
-      return (array) => lastIndexOfFrom(array, searchElement, fromIndex);
-    }
+    case 2:
+      return (array) => lastIndexOfFromImpl(array, ...args);
   }
 }
+
+const lastIndexOfFromImpl = <E,>(
+  array: readonly E[],
+  searchElement: E,
+  fromIndex: SizeType.ArgArrWithNegative,
+): SizeType.Arr | -1 => {
+  const index = array.lastIndexOf(searchElement, fromIndex);
+
+  return index !== -1 ? asUint32(index) : -1;
+};

package/src/array/impl/array-utils-slice-clamped.mts

@@ -39,21 +39,23 @@ export function sliceClamped<E>(
     | readonly [SizeType.ArgArrWithNegative, SizeType.ArgArrWithNegative]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 3: {
-      const [array, start, end] = args;
+    case 3:
+      return sliceClampedImpl(...args);
 
-      const startClamped = Num.clamp(0, array.length)(start);
-
-      // Ensure endClamped is not less than startClamped.
-      const endClamped = Num.clamp(startClamped, array.length)(end);
+    case 2:
+      return (array) => sliceClampedImpl(array, ...args);
+  }
+}
 
-      return array.slice(startClamped, endClamped);
-    }
+const sliceClampedImpl = <E,>(
+  array: readonly E[],
+  start: SizeType.ArgArrWithNegative,
+  end: SizeType.ArgArrWithNegative,
+): readonly E[] => {
+  const startClamped = Num.clamp(0, array.length)(start);
 
-    case 2: {
-      const [start, end] = args;
+  // Ensure endClamped is not less than startClamped.
+  const endClamped = Num.clamp(startClamped, array.length)(end);
 
-      return (array) => sliceClamped(array, start, end);
-    }
-  }
-}
+  return array.slice(startClamped, endClamped);
+};

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

@@ -115,20 +115,19 @@ export function take<E>(
     | readonly [num: SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return takeImpl(...args);
 
-      return sliceClamped(array, 0, num);
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => take(array, num);
-    }
+    case 1:
+      return (array) => takeImpl(array, ...args);
   }
 }
 
+const takeImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, 0, num);
+
 /**
  * Takes the last N elements from an array.
  *
@@ -178,20 +177,20 @@ export function takeLast<E>(
     | readonly [num: SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return takeLastImpl(...args);
 
-      return sliceClamped(array, Uint32.sub(size(array), num), size(array));
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => takeLast(array, num);
-    }
+    case 1:
+      return (array) => takeLastImpl(array, ...args);
   }
 }
 
+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.
  *
@@ -230,20 +229,19 @@ export function skip<E>(
   ...args: readonly [readonly E[], SizeType.ArgArr] | readonly [SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return skipImpl(...args);
 
-      return sliceClamped(array, num, size(array));
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => skip(array, num);
-    }
+    case 1:
+      return (array) => skipImpl(array, ...args);
   }
 }
 
+const skipImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, num, size(array));
+
 /**
  * Skips the last N elements of an array.
  *
@@ -286,20 +284,19 @@ export function skipLast<E>(
     | readonly [num: SizeType.ArgArr]
 ): readonly E[] | ((array: readonly E[]) => readonly E[]) {
   switch (args.length) {
-    case 2: {
-      const [array, num] = args;
+    case 2:
+      return skipLastImpl(...args);
 
-      return sliceClamped(array, 0, Uint32.sub(size(array), num));
-    }
-
-    case 1: {
-      const [num] = args;
-
-      return (array) => skipLast(array, num);
-    }
+    case 1:
+      return (array) => skipLastImpl(array, ...args);
   }
 }
 
+const skipLastImpl = <E,>(
+  array: readonly E[],
+  num: SizeType.ArgArr,
+): readonly E[] => sliceClamped(array, 0, Uint32.sub(size(array), num));
+
 /**
  * Alias for `tail`.
  *