ts-data-forge 1.5.0 → 1.5.2

package/dist/array/array-utils.d.mts

@@ -97,12 +97,9 @@ export declare namespace Arr {
      * @see {@link isEmpty} for checking if size is 0
      * @see {@link isNonEmpty} for checking if size > 0
      */
-    export const size: SizeFnOverload;
-    type SizeFnOverload = {
-        <Ar extends NonEmptyArray<unknown>>(array: Ar): IntersectBrand<PositiveNumber, SizeType.Arr>;
-        <Ar extends readonly unknown[]>(array: Ar): SizeType.Arr;
-    };
-    export const length: SizeFnOverload;
+    export function size<Ar extends NonEmptyArray<unknown>>(array: Ar): IntersectBrand<PositiveNumber, SizeType.Arr>;
+    export function size<Ar extends readonly unknown[]>(array: Ar): SizeType.Arr;
+    export const length: typeof size;
     /**
      * Type guard that checks if a value is an array, excluding types that cannot be arrays.
      * This function refines the type by filtering out non-array types from unions.
@@ -391,21 +388,18 @@ export declare namespace Arr {
      * expectType<typeof maybeEmpty, readonly 0[]>('=');
      * ```
      */
-    export const zeros: ZerosFnOverload;
-    type ZerosFnOverload = {
-        /**
-         * Create array of zeros with compile-time length.
-         */
-        <N extends SmallUint>(len: N): ArrayOfLength<N, 0>;
-        /**
-         * Create non-empty array of zeros.
-         */
-        (len: SizeType.ArgArrPositive): NonEmptyArray<0>;
-        /**
-         * Create array of zeros.
-         */
-        (len: SizeType.ArgArrNonNegative): readonly 0[];
-    };
+    /**
+     * Create array of zeros with compile-time length.
+     */
+    export function zeros<N extends SmallUint>(len: N): ArrayOfLength<N, 0>;
+    /**
+     * Create non-empty array of zeros.
+     */
+    export function zeros(len: SizeType.ArgArrPositive): NonEmptyArray<0>;
+    /**
+     * Create array of zeros.
+     */
+    export function zeros(len: SizeType.ArgArrNonNegative): readonly 0[];
     /**
      * Creates a sequence of consecutive integers from 0 to `len-1`.
      *
@@ -447,12 +441,9 @@ export declare namespace Arr {
      * expectType<typeof single, readonly [0]>('=');
      * ```
      */
-    export const seq: SeqFnOverload;
-    type SeqFnOverload = {
-        <N extends SmallUint>(len: N): Seq<N>;
-        (len: SizeType.ArgArrPositive): NonEmptyArray<SizeType.Arr>;
-        (len: SizeType.ArgArrNonNegative): readonly SizeType.Arr[];
-    };
+    export function seq<N extends SmallUint>(len: N): Seq<N>;
+    export function seq(len: SizeType.ArgArrPositive): NonEmptyArray<SizeType.Arr>;
+    export function seq(len: SizeType.ArgArrNonNegative): readonly SizeType.Arr[];
     /**
      * Creates a new array of the specified length, with each position filled with the provided initial value.
      *
@@ -501,13 +492,10 @@ export declare namespace Arr {
      * @see {@link zeros} for creating arrays filled with zeros
      * @see {@link seq} for creating sequences of consecutive integers
      */
-    export const create: CreateFnOverload;
-    type CreateFnOverload = {
-        <const V, N extends SmallUint>(len: N, init: V): ArrayOfLength<N, V>;
-        <const V>(len: SizeType.ArgArrPositive, init: V): NonEmptyArray<V>;
-        <const V>(len: SizeType.ArgArrNonNegative, init: V): readonly V[];
-    };
-    export const newArray: CreateFnOverload;
+    export function create<const V, N extends SmallUint>(len: N, init: V): ArrayOfLength<N, V>;
+    export function create<const V>(len: SizeType.ArgArrPositive, init: V): NonEmptyArray<V>;
+    export function create<const V>(len: SizeType.ArgArrNonNegative, init: V): readonly V[];
+    export const newArray: typeof create;
     /**
      * Creates an array from a generator function.
      *
@@ -707,12 +695,9 @@ export declare namespace Arr {
      * @see {@link SmallUint} for understanding the constraint that enables precise typing
      * @see {@link SafeInt} and {@link SafeUint} for the safe integer types used
      */
-    export const range: RangeFnOverload;
-    type RangeFnOverload = {
-        <S extends SmallUint, E extends SmallUint>(start: S, end: E, step?: 1): RangeList<S, E>;
-        (start: SafeUintWithSmallInt, end: SafeUintWithSmallInt, step?: PositiveSafeIntWithSmallInt): readonly SafeUint[];
-        (start: SafeIntWithSmallInt, end: SafeIntWithSmallInt, step?: NonZeroSafeIntWithSmallInt): readonly SafeInt[];
-    };
+    export function range<S extends SmallUint, E extends SmallUint>(start: S, end: E, step?: 1): RangeList<S, E>;
+    export function range(start: SafeUintWithSmallInt, end: SafeUintWithSmallInt, step?: PositiveSafeIntWithSmallInt): readonly SafeUint[];
+    export function range(start: SafeIntWithSmallInt, end: SafeIntWithSmallInt, step?: NonZeroSafeIntWithSmallInt): readonly SafeInt[];
     /**
      * Safely retrieves an element at a given index from an array, returning an {@link Optional}.
      *
@@ -823,14 +808,8 @@ export declare namespace Arr {
      * @see {@link Optional.unwrapOr} for safe unwrapping with defaults
      * @see {@link Optional.map} for transforming Optional values
      */
-    export const at: AtFnOverload;
-    /**
-     * Function type for safely accessing an array element at a given index.
-     */
-    type AtFnOverload = {
-        <E>(array: readonly E[], index: SizeType.ArgArr): Optional<E>;
-        (index: SizeType.ArgArr): <E>(array: readonly E[]) => Optional<E>;
-    };
+    export function at<E>(array: readonly E[], index: SizeType.ArgArr): Optional<E>;
+    export function at(index: SizeType.ArgArr): <E>(array: readonly E[]) => Optional<E>;
     /**
      * Returns the first element of an array wrapped in an Optional.
      *
@@ -902,25 +881,10 @@ export declare namespace Arr {
      * @see {@link at} for accessing elements at specific indices
      * @see {@link tail} for getting all elements except the first
      */
-    export const head: HeadFnOverload;
-    type HeadFnOverload = {
-        /**
-         * Get head of empty array.
-         */
-        (array: readonly []): Optional.None;
-        /**
-         * Get head of tuple.
-         */
-        <E, L extends readonly unknown[]>(array: readonly [E, ...L]): Optional.Some<E>;
-        /**
-         * Get head of non-empty array.
-         */
-        <E>(array: NonEmptyArray<E>): Optional.Some<E>;
-        /**
-         * Get head of any array.
-         */
-        <E>(array: readonly E[]): Optional<E>;
-    };
+    export function head(array: readonly []): Optional.None;
+    export function head<E, L extends readonly unknown[]>(array: readonly [E, ...L]): Optional.Some<E>;
+    export function head<E>(array: NonEmptyArray<E>): Optional.Some<E>;
+    export function head<E>(array: readonly E[]): Optional<E>;
     /**
      * Returns the last element of an array wrapped in an Optional.
      *
@@ -1001,25 +965,10 @@ export declare namespace Arr {
      * @see {@link at} for accessing elements at specific indices with negative indexing support
      * @see {@link butLast} for getting all elements except the last
      */
-    export const last: LastFnOverload;
-    type LastFnOverload = {
-        /**
-         * Get last of empty array.
-         */
-        (array: readonly []): Optional.None;
-        /**
-         * Get last of tuple.
-         */
-        <Ar extends readonly unknown[], L>(array: readonly [...Ar, L]): Optional.Some<L>;
-        /**
-         * Get last of non-empty array.
-         */
-        <E>(array: NonEmptyArray<E>): Optional.Some<E>;
-        /**
-         * Get last of any array.
-         */
-        <E>(array: readonly E[]): Optional<E>;
-    };
+    export function last(array: readonly []): Optional.None;
+    export function last<Ar extends readonly unknown[], L>(array: readonly [...Ar, L]): Optional.Some<L>;
+    export function last<E>(array: NonEmptyArray<E>): Optional.Some<E>;
+    export function last<E>(array: readonly E[]): Optional<E>;
     /**
      * Slices an array with automatically clamped start and end indices for safe bounds handling.
      *
@@ -1103,11 +1052,8 @@ export declare namespace Arr {
      * @see {@link skip} for skipping the first N elements
      * @see {@link takeLast} for taking the last N elements
      */
-    export const sliceClamped: SliceClampedFnOverload;
-    type SliceClampedFnOverload = {
-        <E>(array: readonly E[], start: SizeType.ArgArr, end: SizeType.ArgArr): readonly E[];
-        (start: SizeType.ArgArr, end: SizeType.ArgArr): <E>(array: readonly E[]) => readonly E[];
-    };
+    export function sliceClamped<E>(array: readonly E[], start: SizeType.ArgArr, end: SizeType.ArgArr): readonly E[];
+    export function sliceClamped(start: SizeType.ArgArr, end: SizeType.ArgArr): <E>(array: readonly E[]) => readonly E[];
     /**
      * Returns all elements of an array except the first one.
      * @template E The type of the array (can be a tuple for more precise typing).
@@ -1157,15 +1103,12 @@ export declare namespace Arr {
      * console.log(result); // [1, 2, 3]
      * ```
      */
-    export const take: TakeFnOverload;
-    type TakeFnOverload = {
-        <Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.Take<N, Ar>;
-        <N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.Take<N, Ar>;
-        <E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): NonEmptyArray<E>;
-        (num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => NonEmptyArray<E>;
-        <E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-        (num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
-    };
+    export function take<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.Take<N, Ar>;
+    export function take<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.Take<N, Ar>;
+    export function take<E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): NonEmptyArray<E>;
+    export function take(num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => NonEmptyArray<E>;
+    export function take<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
+    export function take(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * Takes the last N elements from an array.
      *
@@ -1189,15 +1132,12 @@ export declare namespace Arr {
      * console.log(result); // [4, 5]
      * ```
      */
-    export const takeLast: TakeLastFnOverload;
-    type TakeLastFnOverload = {
-        <Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.TakeLast<N, Ar>;
-        <N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.TakeLast<N, Ar>;
-        <E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): NonEmptyArray<E>;
-        (num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => NonEmptyArray<E>;
-        <E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-        (num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
-    };
+    export function takeLast<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.TakeLast<N, Ar>;
+    export function takeLast<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.TakeLast<N, Ar>;
+    export function takeLast<E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): NonEmptyArray<E>;
+    export function takeLast(num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => NonEmptyArray<E>;
+    export function takeLast<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
+    export function takeLast(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * Skips the first N elements of an array.
      *
@@ -1221,15 +1161,12 @@ export declare namespace Arr {
      * console.log(result); // [3, 4, 5]
      * ```
      */
-    export const skip: SkipFnOverload;
-    type SkipFnOverload = {
-        <Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.Skip<N, Ar>;
-        <E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): readonly E[];
-        <E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-        <N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.Skip<N, Ar>;
-        (num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => readonly E[];
-        (num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
-    };
+    export function skip<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.Skip<N, Ar>;
+    export function skip<E>(array: NonEmptyArray<E>, num: SizeType.ArgArrPositive): readonly E[];
+    export function skip<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
+    export function skip<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.Skip<N, Ar>;
+    export function skip(num: SizeType.ArgArrPositive): <E>(array: NonEmptyArray<E>) => readonly E[];
+    export function skip(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * Skips the last N elements of an array.
      *
@@ -1253,13 +1190,10 @@ export declare namespace Arr {
      * console.log(result); // [1, 2, 3]
      * ```
      */
-    export const skipLast: SkipLastFnOverload;
-    type SkipLastFnOverload = {
-        <Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.SkipLast<N, Ar>;
-        <E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
-        <N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.SkipLast<N, Ar>;
-        (num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
-    };
+    export function skipLast<Ar extends readonly unknown[], N extends SmallUint>(array: Ar, num: N): List.SkipLast<N, Ar>;
+    export function skipLast<N extends SmallUint>(num: N): <Ar extends readonly unknown[]>(array: Ar) => List.SkipLast<N, Ar>;
+    export function skipLast<E>(array: readonly E[], num: SizeType.ArgArrNonNegative): readonly E[];
+    export function skipLast(num: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * Returns a new array with the element at the specified index updated by a function.
      *
@@ -1414,11 +1348,8 @@ export declare namespace Arr {
      * @see {@link SizeType.ArgArrNonNegative} for the index type constraint
      * @see Immutable update patterns for functional programming approaches
      */
-    export const toUpdated: ToUpdatedFnOverload;
-    type ToUpdatedFnOverload = {
-        <E, U>(array: readonly E[], index: SizeType.ArgArrNonNegative, updater: (prev: E) => U): readonly (E | U)[];
-        <E, U>(index: SizeType.ArgArrNonNegative, updater: (prev: E) => U): (array: readonly E[]) => readonly (E | U)[];
-    };
+    export function toUpdated<E, U>(array: readonly E[], index: SizeType.ArgArrNonNegative, updater: (prev: E) => U): readonly (E | U)[];
+    export function toUpdated<E, U>(index: SizeType.ArgArrNonNegative, updater: (prev: E) => U): (array: readonly E[]) => readonly (E | U)[];
     /**
      * Returns a new array with a new value inserted at the specified index.
      * Index can be out of bounds (e.g., negative or greater than length), `toSpliced` handles this.
@@ -1438,11 +1369,8 @@ export declare namespace Arr {
      * console.log(result); // [99, 1, 2, 3]
      * ```
      */
-    export const toInserted: ToInsertedFnOverload;
-    type ToInsertedFnOverload = {
-        <E, const V = E>(array: readonly E[], index: SizeType.ArgArrNonNegative, newValue: V): NonEmptyArray<E | V>;
-        <E, const V = E>(index: SizeType.ArgArrNonNegative, newValue: V): (array: readonly E[]) => NonEmptyArray<E | V>;
-    };
+    export function toInserted<E, const V = E>(array: readonly E[], index: SizeType.ArgArrNonNegative, newValue: V): NonEmptyArray<E | V>;
+    export function toInserted<E, const V = E>(index: SizeType.ArgArrNonNegative, newValue: V): (array: readonly E[]) => NonEmptyArray<E | V>;
     /**
      * Returns a new array with the element at the specified index removed.
      * If index is out of bounds, `toSpliced` handles this (usually by returning a copy).
@@ -1461,11 +1389,8 @@ export declare namespace Arr {
      * console.log(result); // [20, 30]
      * ```
      */
-    export const toRemoved: ToRemovedFnOverload;
-    type ToRemovedFnOverload = {
-        <E>(array: readonly E[], index: SizeType.ArgArrNonNegative): readonly E[];
-        (index: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
-    };
+    export function toRemoved<E>(array: readonly E[], index: SizeType.ArgArrNonNegative): readonly E[];
+    export function toRemoved(index: SizeType.ArgArrNonNegative): <E>(array: readonly E[]) => readonly E[];
     /**
      * Returns a new array with a value added to the end.
      * @template E The type of the input array (can be a tuple).
@@ -1484,11 +1409,8 @@ export declare namespace Arr {
      * console.log(result); // [1, 2, 3, 0]
      * ```
      */
-    export const toPushed: ToPushedFnOverload;
-    type ToPushedFnOverload = {
-        <Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [...Ar, V];
-        <const V>(newValue: V): <Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];
-    };
+    export function toPushed<Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [...Ar, V];
+    export function toPushed<const V>(newValue: V): <Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];
     /**
      * Returns a new array with a value added to the beginning.
      * @template E The type of the input array (can be a tuple).
@@ -1507,11 +1429,8 @@ export declare namespace Arr {
      * console.log(result); // [0, 1, 2, 3]
      * ```
      */
-    export const toUnshifted: ToUnshiftedFnOverload;
-    type ToUnshiftedFnOverload = {
-        <Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [V, ...Ar];
-        <const V>(newValue: V): <Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];
-    };
+    export function toUnshifted<Ar extends readonly unknown[], const V>(array: Ar, newValue: V): readonly [V, ...Ar];
+    export function toUnshifted<const V>(newValue: V): <Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];
     /**
      * Fills an array with a value (creates a new filled array).
      * @param array The array.
@@ -1532,16 +1451,10 @@ export declare namespace Arr {
      * console.log(result2); // [1, 0, 0, 4]
      * ```
      */
-    export const toFilled: ToFilledFnOverload;
-    type ToFilledFnOverload = {
-        <E>(array: readonly E[], value: E): readonly E[];
-        <E>(value: E): (array: readonly E[]) => readonly E[];
-    };
-    export const toRangeFilled: ToRangeFilledFnOverload;
-    type ToRangeFilledFnOverload = {
-        <E>(array: readonly E[], value: E, fillRange: readonly [start: SizeType.ArgArr, end: SizeType.ArgArr]): readonly E[];
-        <E>(value: E, fillRange: readonly [start: SizeType.ArgArr, end: SizeType.ArgArr]): (array: readonly E[]) => readonly E[];
-    };
+    export function toFilled<E>(array: readonly E[], value: E): readonly E[];
+    export function toFilled<E>(value: E): (array: readonly E[]) => readonly E[];
+    export function toRangeFilled<E>(array: readonly E[], value: E, fillRange: readonly [start: SizeType.ArgArr, end: SizeType.ArgArr]): readonly E[];
+    export function toRangeFilled<E>(value: E, fillRange: readonly [start: SizeType.ArgArr, end: SizeType.ArgArr]): (array: readonly E[]) => readonly E[];
     /**
      * Safely finds the first element in an array that satisfies a predicate function.
      *
@@ -1564,83 +1477,23 @@ export declare namespace Arr {
      *
      * @example
      * ```typescript
-     * // Basic element finding
      * const numbers = [1, 2, 3, 4, 5];
      * const firstEven = Arr.find(numbers, x => x % 2 === 0);
      * if (Optional.isSome(firstEven)) {
-     *   console.log(firstEven.value); // 2 - first even number
+     *   console.log(firstEven.value); // 2
      * }
      *
-     * // Finding with index information
-     * const findLargeAtEnd = Arr.find(numbers, (value, index) => value > 3 && index > 2);
-     * // Optional.Some(4) - first number > 3 after index 2
-     *
-     * // Finding objects by property
-     * const users = [
-     *   { id: 1, name: 'Alice', age: 25 },
-     *   { id: 2, name: 'Bob', age: 30 },
-     *   { id: 3, name: 'Charlie', age: 35 }
-     * ];
-     *
+     * const users = [{ id: 1, name: 'Alice', age: 25 }, { id: 2, name: 'Bob', age: 30 }];
      * const adult = Arr.find(users, user => user.age >= 30);
      * // Optional.Some({ id: 2, name: 'Bob', age: 30 })
-     *
-     * const nonExistent = Arr.find(users, user => user.age > 100);
-     * // Optional.None
-     *
-     * // Empty array handling
-     * const emptyResult = Arr.find([], x => x > 0); // Optional.None
-     *
-     * // Curried usage for functional composition
-     * const findNegative = Arr.find((x: number) => x < 0);
-     * const findLongString = Arr.find((s: string) => s.length > 5);
-     *
-     * const datasets = [
-     *   [1, 2, -3, 4],
-     *   [5, 6, 7, 8],
-     *   [-1, 0, 1]
-     * ];
-     *
-     * const negativeNumbers = datasets.map(findNegative);
-     * // [Optional.Some(-3), Optional.None, Optional.Some(-1)]
-     *
-     * // Pipe composition
-     * const result = pipe(['short', 'medium', 'very long string'])
-     *   .map(findLongString)
-     *   .map(opt => Optional.unwrapOr(opt, 'default'))
-     *   .value; // 'very long string'
-     *
-     * // Complex predicate with all parameters
-     * const findSpecial = (arr: readonly number[]) =>
-     *   Arr.find(arr, (value, index, array) => {
-     *     return value > 10 && index > 0 && index < array.length - 1;
-     *   });
-     *
-     * const hasMiddleSpecial = findSpecial([5, 15, 20, 3]);
-     * // Optional.Some(15) - first value > 10 that's not at start or end
-     *
-     * // Safe unwrapping patterns
-     * const maybeFound = Arr.find(numbers, x => x > 10);
-     * const foundOrDefault = Optional.unwrapOr(maybeFound, 0); // 0 (not found)
-     * const foundOrThrow = Optional.isSome(maybeFound)
-     *   ? maybeFound.value
-     *   : (() => { throw new Error('Not found'); })();
-     *
-     * // Type inference examples
-     * expectType<typeof firstEven, Optional<number>>('=');
-     * expectType<typeof adult, Optional<{id: number, name: string, age: number}>>('=');
-     * expectType<typeof findNegative, (array: readonly number[]) => Optional<number>>('=');
      * ```
      *
      * @see {@link findIndex} for finding the index instead of the element
      * @see {@link indexOf} for finding elements by equality
      * @see {@link Optional} for working with the returned Optional values
      */
-    export const find: FindFnOverload;
-    type FindFnOverload = {
-        <E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): Optional<E>;
-        <E>(predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): (array: readonly E[]) => Optional<E>;
-    };
+    export function find<E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): Optional<E>;
+    export function find<E>(predicate: (value: E, index: SizeType.Arr, arr: readonly E[]) => boolean): (array: readonly E[]) => Optional<E>;
     /**
      * Safely finds the index of the first element in an array that satisfies a predicate function.
      *
@@ -1746,11 +1599,8 @@ export declare namespace Arr {
      * @see {@link lastIndexOf} for finding the last occurrence
      * @see {@link Optional} for working with the returned Optional values
      */
-    export const findIndex: FindIndexFnOverload;
-    type FindIndexFnOverload = {
-        <E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr) => boolean): SizeType.Arr | -1;
-        <E>(predicate: (value: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => SizeType.Arr | -1;
-    };
+    export function findIndex<E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr) => boolean): SizeType.Arr | -1;
+    export function findIndex<E>(predicate: (value: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => SizeType.Arr | -1;
     /**
      * Gets the index of a value in an array.
      * @param array The array to search.
@@ -1772,16 +1622,10 @@ export declare namespace Arr {
      * console.log(Optional.unwrapOr(result2, -1)); // 1
      * ```
      */
-    export const indexOf: IndexOfFnOverload;
-    type IndexOfFnOverload = {
-        <E>(array: readonly E[], searchElement: E): SizeType.Arr | -1;
-        <E>(searchElement: E): (array: readonly E[]) => SizeType.Arr | -1;
-    };
-    export const indexOfFrom: IndexOfFromFnOverload;
-    type IndexOfFromFnOverload = {
-        <E>(array: readonly E[], searchElement: E, fromIndex: SizeType.ArgArr): SizeType.Arr | -1;
-        <E>(searchElement: E, fromIndex: SizeType.ArgArr): (array: readonly E[]) => SizeType.Arr | -1;
-    };
+    export function indexOf<E>(array: readonly E[], searchElement: E): SizeType.Arr | -1;
+    export function indexOf<E>(searchElement: E): (array: readonly E[]) => SizeType.Arr | -1;
+    export function indexOfFrom<E>(array: readonly E[], searchElement: E, fromIndex: SizeType.ArgArr): SizeType.Arr | -1;
+    export function indexOfFrom<E>(searchElement: E, fromIndex: SizeType.ArgArr): (array: readonly E[]) => SizeType.Arr | -1;
     /**
      * Gets the last index of a value in an array.
      * @param array The array to search.
@@ -1803,16 +1647,10 @@ export declare namespace Arr {
      * console.log(Optional.unwrapOr(result2, -1)); // 3
      * ```
      */
-    export const lastIndexOf: LastIndexOfFnOverload;
-    type LastIndexOfFnOverload = {
-        <E>(array: readonly E[], searchElement: E): SizeType.Arr | -1;
-        <E>(searchElement: E): (array: readonly E[]) => SizeType.Arr | -1;
-    };
-    export const lastIndexOfFrom: LastIndexOfFromFnOverload;
-    type LastIndexOfFromFnOverload = {
-        <E>(array: readonly E[], searchElement: E, fromIndex: SizeType.ArgArr): SizeType.Arr | -1;
-        <E>(searchElement: E, fromIndex: SizeType.ArgArr): (array: readonly E[]) => SizeType.Arr | -1;
-    };
+    export function lastIndexOf<E>(array: readonly E[], searchElement: E): SizeType.Arr | -1;
+    export function lastIndexOf<E>(searchElement: E): (array: readonly E[]) => SizeType.Arr | -1;
+    export function lastIndexOfFrom<E>(array: readonly E[], searchElement: E, fromIndex: SizeType.ArgArr): SizeType.Arr | -1;
+    export function lastIndexOfFrom<E>(searchElement: E, fromIndex: SizeType.ArgArr): (array: readonly E[]) => SizeType.Arr | -1;
     /**
      * Applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.
      * This is an alias for `Array.prototype.reduce`.
@@ -1824,20 +1662,12 @@ export declare namespace Arr {
      * @returns The single value that results from the reduction.
      * @example
      * ```ts
-     * // Regular usage
      * Arr.foldl([1, 2, 3], (sum, n) => sum + n, 0); // 6
-     *
-     * // Curried usage for pipe composition
-     * const sumWithZero = Arr.foldl((sum: number, n: number) => sum + n, 0);
-     * const result = pipe([1, 2, 3, 4]).map(sumWithZero).value;
-     * console.log(result); // 10
+     * Arr.foldl(['a', 'b', 'c'], (acc, str) => acc + str.toUpperCase(), ''); // 'ABC'
      * ```
      */
-    export const foldl: FoldlFnOverload;
-    type FoldlFnOverload = {
-        <E, P>(array: readonly E[], callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): P;
-        <E, P>(callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): (array: readonly E[]) => P;
-    };
+    export function foldl<E, P>(array: readonly E[], callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): P;
+    export function foldl<E, P>(callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): (array: readonly E[]) => P;
     /**
      * Applies a function against an accumulator and each element in the array (from right to left) to reduce it to a single value.
      * This is an alias for `Array.prototype.reduceRight`.
@@ -1858,11 +1688,8 @@ export declare namespace Arr {
      * console.log(result); // "abc"
      * ```
      */
-    export const foldr: FoldrFnOverload;
-    type FoldrFnOverload = {
-        <E, P>(array: readonly E[], callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): P;
-        <E, P>(callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): (array: readonly E[]) => P;
-    };
+    export function foldr<E, P>(array: readonly E[], callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): P;
+    export function foldr<E, P>(callbackfn: (previousValue: P, currentValue: E, currentIndex: SizeType.Arr) => P, initialValue: P): (array: readonly E[]) => P;
     /**
      * Finds the minimum value in an array.
      * @template E The type of numbers in the array (must extend `number`).
@@ -1876,13 +1703,10 @@ export declare namespace Arr {
      * Arr.min([]); // Optional.none
      * ```
      */
-    export const min: MinFnOverload;
-    type MinFnOverload = {
-        <E extends number>(array: NonEmptyArray<E>, comparator?: (x: E, y: E) => number): Optional.Some<E>;
-        <E extends number>(array: readonly E[], comparator?: (x: E, y: E) => number): Optional<E>;
-        <E>(array: NonEmptyArray<E>, comparator: (x: E, y: E) => number): Optional.Some<E>;
-        <E>(array: readonly E[], comparator: (x: E, y: E) => number): Optional<E>;
-    };
+    export function min<E extends number>(array: NonEmptyArray<E>, comparator?: (x: E, y: E) => number): Optional.Some<E>;
+    export function min<E extends number>(array: readonly E[], comparator?: (x: E, y: E) => number): Optional<E>;
+    export function min<E>(array: NonEmptyArray<E>, comparator: (x: E, y: E) => number): Optional.Some<E>;
+    export function min<E>(array: readonly E[], comparator: (x: E, y: E) => number): Optional<E>;
     /**
      * Finds the maximum value in an array.
      *
@@ -1901,13 +1725,10 @@ export declare namespace Arr {
      * Arr.max([]); // Optional.none
      * ```
      */
-    export const max: MaxFnOverload;
-    type MaxFnOverload = {
-        <E extends number>(array: NonEmptyArray<E>, comparator?: (x: E, y: E) => number): Optional.Some<E>;
-        <E extends number>(array: readonly E[], comparator?: (x: E, y: E) => number): Optional<E>;
-        <E>(array: NonEmptyArray<E>, comparator: (x: E, y: E) => number): Optional.Some<E>;
-        <E>(array: readonly E[], comparator: (x: E, y: E) => number): Optional<E>;
-    };
+    export function max<E extends number>(array: NonEmptyArray<E>, comparator?: (x: E, y: E) => number): Optional.Some<E>;
+    export function max<E extends number>(array: readonly E[], comparator?: (x: E, y: E) => number): Optional<E>;
+    export function max<E>(array: NonEmptyArray<E>, comparator: (x: E, y: E) => number): Optional.Some<E>;
+    export function max<E>(array: readonly E[], comparator: (x: E, y: E) => number): Optional<E>;
     /**
      * Finds the element with the minimum value according to a mapped numeric value.
      *
@@ -1928,13 +1749,10 @@ export declare namespace Arr {
      * Arr.minBy([], p => p.age); // Optional.none
      * ```
      */
-    export const minBy: MinByFnOverload;
-    type MinByFnOverload = {
-        <E>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => number): Optional.Some<E>;
-        <E>(array: readonly E[], comparatorValueMapper: (value: E) => number): Optional<E>;
-        <E, V>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional.Some<E>;
-        <E, V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional<E>;
-    };
+    export function minBy<E>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => number): Optional.Some<E>;
+    export function minBy<E>(array: readonly E[], comparatorValueMapper: (value: E) => number): Optional<E>;
+    export function minBy<E, V>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional.Some<E>;
+    export function minBy<E, V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional<E>;
     /**
      * Finds the element with the maximum value according to a mapped numeric value.
      *
@@ -1955,13 +1773,10 @@ export declare namespace Arr {
      * Arr.maxBy([], p => p.age); // Optional.none
      * ```
      */
-    export const maxBy: MaxByFnOverload;
-    type MaxByFnOverload = {
-        <E>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => number): Optional.Some<E>;
-        <E>(array: readonly E[], comparatorValueMapper: (value: E) => number): Optional<E>;
-        <E, V>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional.Some<E>;
-        <E, V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional<E>;
-    };
+    export function maxBy<E>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => number): Optional.Some<E>;
+    export function maxBy<E>(array: readonly E[], comparatorValueMapper: (value: E) => number): Optional<E>;
+    export function maxBy<E, V>(array: NonEmptyArray<E>, comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional.Some<E>;
+    export function maxBy<E, V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): Optional<E>;
     /**
      * Counts the number of elements in an array that satisfy a predicate.
      * @template E The type of elements in the array.
@@ -1979,11 +1794,8 @@ export declare namespace Arr {
      * console.log(result); // 3
      * ```
      */
-    export const count: CountFnOverload;
-    type CountFnOverload = {
-        <E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr) => boolean): SizeType.Arr;
-        <E>(predicate: (value: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => SizeType.Arr;
-    };
+    export function count<E>(array: readonly E[], predicate: (value: E, index: SizeType.Arr) => boolean): SizeType.Arr;
+    export function count<E>(predicate: (value: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => SizeType.Arr;
     /**
      * Groups elements of an array by a key derived from each element and counts the elements in each group.
      * @template E The type of elements in the array.
@@ -2004,11 +1816,8 @@ export declare namespace Arr {
      * // IMap { 'a' => 2, 'b' => 1 }
      * ```
      */
-    export const countBy: CountByFnOverload;
-    type CountByFnOverload = {
-        <E, G extends MapSetKeyType>(array: readonly E[], grouper: (value: E, index: SizeType.Arr) => G): IMap<G, SizeType.Arr>;
-        <E, G extends MapSetKeyType>(grouper: (value: E, index: SizeType.Arr) => G): (array: readonly E[]) => IMap<G, SizeType.Arr>;
-    };
+    export function countBy<E, G extends MapSetKeyType>(array: readonly E[], grouper: (value: E, index: SizeType.Arr) => G): IMap<G, SizeType.Arr>;
+    export function countBy<E, G extends MapSetKeyType>(grouper: (value: E, index: SizeType.Arr) => G): (array: readonly E[]) => IMap<G, SizeType.Arr>;
     /**
      * Calculates the sum of numbers in an array.
      * @param array The input array of numbers.
@@ -2020,14 +1829,11 @@ export declare namespace Arr {
      * Arr.sum([-1, 0, 1]); // 0
      * ```
      */
-    export const sum: SumFnOverload;
-    type SumFnOverload = {
-        (array: readonly []): 0;
-        <N extends number>(array: readonly [N]): N;
-        (array: readonly Uint[]): Uint;
-        (array: readonly Int[]): Int;
-        (array: readonly number[]): number;
-    };
+    export function sum(array: readonly []): 0;
+    export function sum<N extends number>(array: readonly [N]): N;
+    export function sum(array: readonly Uint[]): Uint;
+    export function sum(array: readonly Int[]): Int;
+    export function sum(array: readonly number[]): number;
     /**
      * Joins array elements into a string.
      * @param array The array to join.
@@ -2048,11 +1854,8 @@ export declare namespace Arr {
      * console.log(Result.unwrapOr(result2, '')); // "a,b,c"
      * ```
      */
-    export const join: JoinFnOverload;
-    type JoinFnOverload = {
-        <E>(array: readonly E[], separator?: string): Result<string, Error>;
-        (separator?: string): <E>(array: readonly E[]) => Result<string, Error>;
-    };
+    export function join<E>(array: readonly E[], separator?: string): Result<string, Error>;
+    export function join(separator?: string): <E>(array: readonly E[]) => Result<string, Error>;
     /**
      * Creates an array of tuples by pairing up corresponding elements from two arrays.
      * The resulting array has a length equal to the minimum of the two input array lengths.
@@ -2088,11 +1891,8 @@ export declare namespace Arr {
      * console.log(result); // [1, 3, 5]
      * ```
      */
-    export const filterNot: FilterNotFnOverload;
-    type FilterNotFnOverload = {
-        <E>(array: readonly E[], predicate: (a: E, index: SizeType.Arr) => boolean): readonly E[];
-        <E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => readonly E[];
-    };
+    export function filterNot<E>(array: readonly E[], predicate: (a: E, index: SizeType.Arr) => boolean): readonly E[];
+    export function filterNot<E>(predicate: (a: E, index: SizeType.Arr) => boolean): (array: readonly E[]) => readonly E[];
     /**
      * Concatenates two arrays.
      * @template E1 The type of the first array (can be a tuple).
@@ -2119,20 +1919,12 @@ export declare namespace Arr {
      * @returns An array of arrays, where each inner array has up to `chunkSize` elements.
      * @example
      * ```ts
-     * // Regular usage
      * Arr.partition([1, 2, 3, 4, 5, 6], 2); // [[1, 2], [3, 4], [5, 6]]
-     *
-     * // Curried usage for pipe composition
-     * const chunkBy3 = Arr.partition(3);
-     * const result = pipe([1, 2, 3, 4, 5, 6, 7]).map(chunkBy3).value;
-     * console.log(result); // [[1, 2, 3], [4, 5, 6], [7]]
+     * Arr.partition([1, 2, 3, 4, 5, 6, 7], 3); // [[1, 2, 3], [4, 5, 6], [7]]
      * ```
      */
-    export const partition: PartitionFnOverload;
-    type PartitionFnOverload = {
-        <N extends WithSmallInt<PositiveInt & SizeType.Arr>, E>(array: readonly E[], chunkSize: N): readonly (readonly E[])[];
-        <N extends WithSmallInt<PositiveInt & SizeType.Arr>>(chunkSize: N): <E>(array: readonly E[]) => readonly (readonly E[])[];
-    };
+    export function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>, E>(array: readonly E[], chunkSize: N): readonly (readonly E[])[];
+    export function partition<N extends WithSmallInt<PositiveInt & SizeType.Arr>>(chunkSize: N): <E>(array: readonly E[]) => readonly (readonly E[])[];
     /**
      * Sorts an array by a value derived from its elements, using a numeric mapping.
      * @template E The type of elements in the array.
@@ -2149,11 +1941,8 @@ export declare namespace Arr {
      * // [{ name: 'Adam', score: 90 }, { name: 'Bob', score: 80 }, { name: 'Eve', score: 70 }]
      * ```
      */
-    export const toSortedBy: ToSortedByFnOverload;
-    type ToSortedByFnOverload = {
-        <E>(array: readonly E[], comparatorValueMapper: (value: E) => number, comparator?: (x: number, y: number) => number): readonly E[];
-        <E, const V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): readonly E[];
-    };
+    export function toSortedBy<E>(array: readonly E[], comparatorValueMapper: (value: E) => number, comparator?: (x: number, y: number) => number): readonly E[];
+    export function toSortedBy<E, const V>(array: readonly E[], comparatorValueMapper: (value: E) => V, comparator: (x: V, y: V) => number): readonly E[];
     /**
      * Returns an array of successively reduced values from an array, starting with an initial value.
      *
@@ -2310,11 +2099,8 @@ export declare namespace Arr {
      * @see {@link SizeType.Arr} for the index parameter type
      * @see Array.prototype.reduce for the standard reduce function
      */
-    export const scan: ScanFnOverload;
-    type ScanFnOverload = {
-        <E, S>(array: readonly E[], reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S, init: S): NonEmptyArray<S>;
-        <E, S>(reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S, init: S): (array: readonly E[]) => NonEmptyArray<S>;
-    };
+    export function scan<E, S>(array: readonly E[], reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S, init: S): NonEmptyArray<S>;
+    export function scan<E, S>(reducer: (accumulator: S, currentValue: E, currentIndex: SizeType.Arr) => S, init: S): (array: readonly E[]) => NonEmptyArray<S>;
     /**
      * Groups elements of an array by a key derived from each element, returning an immutable {@link IMap}.
      *
@@ -2464,11 +2250,8 @@ export declare namespace Arr {
      * @see {@link IMap.map} for transforming grouped data
      * @see {@link Optional} for handling potentially missing groups
      */
-    export const groupBy: GroupByFnOverload;
-    type GroupByFnOverload = {
-        <E, G extends MapSetKeyType>(array: readonly E[], grouper: (value: E, index: SizeType.Arr) => G): IMap<G, readonly E[]>;
-        <E, G extends MapSetKeyType>(grouper: (value: E, index: SizeType.Arr) => G): (array: readonly E[]) => IMap<G, readonly E[]>;
-    };
+    export function groupBy<E, G extends MapSetKeyType>(array: readonly E[], grouper: (value: E, index: SizeType.Arr) => G): IMap<G, readonly E[]>;
+    export function groupBy<E, G extends MapSetKeyType>(grouper: (value: E, index: SizeType.Arr) => G): (array: readonly E[]) => IMap<G, readonly E[]>;
     /**
      * Creates a new array with unique elements from the input array. Order is preserved from the first occurrence.
      * Uses `Set` internally for efficient uniqueness checking.
@@ -2478,7 +2261,6 @@ export declare namespace Arr {
      * @example
      * ```ts
      * Arr.uniq([1, 2, 2, 3, 1, 4]); // [1, 2, 3, 4]
-     * Arr.uniq(['a', 'b', 'a']); // ['a', 'b']
      * ```
      */
     export const uniq: <P extends Primitive>(array: readonly P[]) => readonly P[];
@@ -2503,11 +2285,8 @@ export declare namespace Arr {
      * Arr.uniqBy(users, user => user.id); // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
      * ```
      */
-    export const uniqBy: UniqByFnOverload;
-    type UniqByFnOverload = {
-        <E, P extends Primitive>(array: NonEmptyArray<E>, mapFn: (value: E) => P): NonEmptyArray<E>;
-        <E, P extends Primitive>(array: readonly E[], mapFn: (value: E) => P): readonly E[];
-    };
+    export function uniqBy<E, P extends Primitive>(array: NonEmptyArray<E>, mapFn: (value: E) => P): NonEmptyArray<E>;
+    export function uniqBy<E, P extends Primitive>(array: readonly E[], mapFn: (value: E) => P): readonly E[];
     /**
      * Checks if two arrays are equal by performing a shallow comparison of their elements.
      * @template E The type of elements in the arrays.
@@ -2618,7 +2397,7 @@ export declare namespace Arr {
      * Alias for `head`. Returns the first element of an array.
      * @see {@link head}
      */
-    export const first: HeadFnOverload;
+    export const first: typeof head;
     /**
      * Alias for `tail`. Returns all elements of an array except the first one.
      * @see {@link tail}
@@ -2628,22 +2407,22 @@ export declare namespace Arr {
      * Alias for `skip`. Skips the first N elements of an array.
      * @see {@link skip}
      */
-    export const drop: SkipFnOverload;
+    export const drop: typeof skip;
     /**
      * Alias for `foldl`. Applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.
      * @see {@link foldl}
      */
-    export const reduce: FoldlFnOverload;
+    export const reduce: typeof foldl;
     /**
      * Alias for `foldr`. Applies a function against an accumulator and each element in the array (from right to left) to reduce it to a single value.
      * @see {@link foldr}
      */
-    export const reduceRight: FoldrFnOverload;
+    export const reduceRight: typeof foldr;
     /**
      * Alias for `partition`. Splits an array into chunks of a specified size.
      * @see {@link partition}
      */
-    export const chunk: PartitionFnOverload;
+    export const chunk: typeof partition;
     export {};
 }
 //# sourceMappingURL=array-utils.d.mts.map