@tempots/std 0.20.0 → 0.22.0

package/array.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const q=require("./object.cjs"),x=(r,t)=>Array.from({length:r.length},(e,n)=>t(r[n],n)),F=(r,t)=>{const e=[];for(const n of r)e.push(...t(n));return e},w=r=>r.length>0?r[0]:void 0,B=r=>r.slice(1),P=(r,t,e)=>{if(r.length!==t.length)return!1;for(let n=0;n<r.length;n++)if(!e(r[n],t[n]))return!1;return!0},b=r=>r.length===0,j=r=>r.length>0,g=(r,t)=>{const e=[];for(const n of r)t(n)&&e.push(n);return e},M=(r,t)=>{const e=[];for(let n=0;n<r.length;n++){const s=t(r[n],n);s!=null&&e.push(s)}return e},I=r=>g(r,t=>t!=null),S=r=>[].concat(...r),k=(r,t,e)=>{for(const n of r)e=t(e,n);return e},D=(r,t)=>{for(const e of r)if(!t(e))return!1;return!0},_=(r,t)=>{for(const e of r)if(t(e))return!0;return!1},T=(r,t)=>{for(const e of r)t(e)},H=(...r)=>[].concat(...r),N=(r,t,e,n=!0)=>{if(r.length<t.length)return-1*(n?1:-1);if(r.length>t.length)return 1*(n?1:-1);for(let s=0;s<r.length;s++){const l=e(r[s],t[s]);if(l!==0)return l}return 0},$=(r,t)=>r.slice().sort(t),p=(r,t)=>Array.from({length:r},(e,n)=>t(n)),C=(r,t=0)=>p(r,e=>t+e),L=(r,t)=>p(r,()=>t),V=r=>Array.from(new Set(r)),W=(r,t)=>{const e={};return r.forEach(n=>{e[t(n)]=n}),q.objectKeys(e).map(n=>e[n])},v=(r,t)=>{const e=r.indexOf(t);return e<0?!1:(r.splice(e,1),!0)},R=(r,t)=>{let e=!1;for(;v(r,t);)e=!0;return e},E=(r,t)=>{const e=r.findIndex(t);return e<0?!1:(r.splice(e,1),!0)},z=(r,t)=>{let e=!1;for(;E(r,t);)e=!0;return e},G=r=>{const t=[];for(let e=r.next();!(e.done??!1);e=r.next())t.push(e.value);return t},J=(r,t,e)=>{const n={removals:[],swaps:[],inserts:[]},{removals:s,inserts:l,swaps:u}=n,c=new Map;t.forEach((a,o)=>c.set(e(a),o));const f=r.map((a,o)=>[a,o]).filter(([a])=>!c.has(e(a))).map(([a,o])=>o);for(let a=f.length-1;a>=0;a--){const o=f[a],i=s.length>0?s[s.length-1]:void 0;i!=null&&i.at===o+1?(i.at--,i.qt++):s.push({at:o,qt:1})}const y=new Map;r.forEach((a,o)=>y.set(e(a),o));const h=t.map((a,o)=>[a,o]).filter(([a])=>!y.has(e(a))).map(([a,o])=>o);for(const a of h){const o=l.length>0?l[l.length-1]:void 0;o!=null&&o.at+o.values.length===a?o.values.push(t[a]):l.push({at:a,values:[t[a]]})}const A=r.filter((a,o)=>!f.includes(o)),m=new Map;for(let a=0;a<A.length;a++)m.set(e(A[a]),a);const d=t.filter((a,o)=>!h.includes(o));for(let a=0;a<d.length;a++){const o=e(d[a]),i=m.get(o);if(i==null||a===i)continue;const O=e(A[a]);m.delete(O),u.push({from:a,to:i})}return n},Q=(r,t)=>{const e=[...t];for(const{at:n,qt:s}of r.removals)e.splice(n,s);for(const{from:n,to:s}of r.swaps){const l=e[s];e[s]=e[n],e[n]=l}for(const n of r.inserts)e.splice(n.at,0,...n.values);return e},U=(r,t=" and ",e=", ")=>r.length===0?"":r.length===1?String(r[0]):`${r.slice(0,-1).join(e)}${t}${String(r[r.length-1])}`,X=(r,t,e=!0)=>{const n=r.map((c,f)=>[c,f]);n.sort((c,f)=>t(c[0],f[0]));const s=new Array(n.length);let l=0,u=n[0][0];for(let c=0;c<n.length;c++){const[f,y]=n[c];t(f,u)!==0&&(l=c,u=f),s[y]=l,e&&l++}return s};exports.allElements=D;exports.anyElement=_;exports.applyArrayDiffOperations=Q;exports.areArraysEqual=P;exports.arrayDiffOperations=J;exports.arrayHasValues=j;exports.arrayHead=w;exports.arrayOfIterableIterator=G;exports.arrayTail=B;exports.compareArrays=N;exports.concatArrays=H;exports.createFilledArray=L;exports.filterArray=g;exports.filterMapArray=M;exports.filterNullsFromArray=I;exports.flatMapArray=F;exports.flattenArray=S;exports.foldLeftArray=k;exports.forEachElement=T;exports.generateArray=p;exports.generateSequenceArray=C;exports.isArrayEmpty=b;exports.joinArrayWithConjunction=U;exports.mapArray=x;exports.rankArray=X;exports.removeAllFromArray=R;exports.removeAllFromArrayByPredicate=z;exports.removeOneFromArray=v;exports.removeOneFromArrayByPredicate=E;exports.sortArray=$;exports.uniqueByPrimitive=W;exports.uniquePrimitives=V;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const w=require("./object.cjs"),B=r=>r.length>0?r[0]:void 0,k=r=>r.slice(1),E=(r,n,t)=>{if(r.length!==n.length)return!1;for(let e=0;e<r.length;e++)if(!t(r[e],n[e]))return!1;return!0},x=r=>r.length===0,F=r=>r.length>0,b=(r,n)=>{const t=[];for(let e=0;e<r.length;e++){const o=n(r[e],e);o!=null&&t.push(o)}return t},j=r=>r.filter(n=>n!=null),q=(r,n,t,e=!0)=>{if(r.length<n.length)return-1*(e?1:-1);if(r.length>n.length)return 1*(e?1:-1);for(let o=0;o<r.length;o++){const a=t(r[o],n[o]);if(a!==0)return a}return 0},g=(r,n)=>Array.from({length:r},(t,e)=>n(e)),P=(r,n=0)=>Array.from({length:r},(t,e)=>n+e),D=(r,n)=>g(r,()=>n),M=(r,n)=>{const t={};return r.forEach(e=>{t[n(e)]=e}),w.objectKeys(t).map(e=>t[e])},d=(r,n)=>{const t=r.indexOf(n);return t<0?!1:(r.splice(t,1),!0)},_=(r,n)=>{let t=!1;for(;d(r,n);)t=!0;return t},v=(r,n)=>{const t=r.findIndex(n);return t<0?!1:(r.splice(t,1),!0)},T=(r,n)=>{let t=!1;for(;v(r,n);)t=!0;return t},H=(r,n,t)=>{const e={removals:[],swaps:[],inserts:[]},{removals:o,inserts:a,swaps:f}=e,i=new Map;n.forEach((s,l)=>i.set(t(s),l));const c=r.map((s,l)=>[s,l]).filter(([s])=>!i.has(t(s))).map(([s,l])=>l);for(let s=c.length-1;s>=0;s--){const l=c[s],u=o.length>0?o[o.length-1]:void 0;u!=null&&u.at===l+1?(u.at--,u.qt++):o.push({at:l,qt:1})}const h=new Map;r.forEach((s,l)=>h.set(t(s),l));const m=n.map((s,l)=>[s,l]).filter(([s])=>!h.has(t(s))).map(([s,l])=>l);for(const s of m){const l=a.length>0?a[a.length-1]:void 0;l!=null&&l.at+l.values.length===s?l.values.push(n[s]):a.push({at:s,values:[n[s]]})}const p=r.filter((s,l)=>!c.includes(l)),y=new Map;for(let s=0;s<p.length;s++)y.set(t(p[s]),s);const A=n.filter((s,l)=>!m.includes(l));for(let s=0;s<A.length;s++){const l=t(A[s]),u=y.get(l);if(u==null||s===u)continue;const O=t(p[s]);y.delete(O),f.push({from:s,to:u})}return e},N=(r,n)=>{const t=[...n];for(const{at:e,qt:o}of r.removals)t.splice(e,o);for(const{from:e,to:o}of r.swaps){const a=t[o];t[o]=t[e],t[e]=a}for(const e of r.inserts)t.splice(e.at,0,...e.values);return t},S=(r,n=" and ",t=", ")=>r.length===0?"":r.length===1?String(r[0]):`${r.slice(0,-1).join(t)}${n}${String(r[r.length-1])}`,C=(r,n,t=!0)=>{const e=r.map((i,c)=>[i,c]);e.sort((i,c)=>n(i[0],c[0]));const o=new Array(e.length);let a=0,f=e[0][0];for(let i=0;i<e.length;i++){const[c,h]=e[i];n(c,f)!==0&&(a=i,f=c),o[h]=a,t&&a++}return o},I=(r,n)=>{if(n<=0)throw new Error("Chunk size must be positive");const t=[];for(let e=0;e<r.length;e+=n)t.push(r.slice(e,e+n));return t},$=(r,n)=>{const t=[],e=[];for(const o of r)n(o)?t.push(o):e.push(o);return[t,e]},V=(r,n)=>{const t={};for(const e of r){const o=n(e);t[o]?t[o].push(e):t[o]=[e]}return t};exports.applyArrayDiffOperations=N;exports.areArraysEqual=E;exports.arrayDiffOperations=H;exports.arrayHasValues=F;exports.arrayHead=B;exports.arrayTail=k;exports.buildArray=g;exports.chunk=I;exports.compareArrays=q;exports.fillArray=D;exports.filterMapArray=b;exports.filterNullsFromArray=j;exports.groupBy=V;exports.isArrayEmpty=x;exports.joinArrayWithConjunction=S;exports.partition=$;exports.range=P;exports.rankArray=C;exports.removeAllFromArray=_;exports.removeAllFromArrayByPredicate=T;exports.removeOneFromArray=d;exports.removeOneFromArrayByPredicate=v;exports.uniqueByPrimitive=M;

package/array.d.ts

@@ -1,95 +1,4 @@
-import { Compare, Maybe, Nothing, Primitive } from './domain';
-/**
- * Transforms each element of an array using a mapping function, returning a new array.
- *
- * This is a functional programming utility that creates a new array by applying a transformation
- * function to each element of the input array. The original array is not modified.
- *
- * @example
- * ```typescript
- * // Transform numbers to strings
- * const numbers = [1, 2, 3, 4, 5]
- * const strings = mapArray(numbers, n => `Number: ${n}`)
- * // Result: ['Number: 1', 'Number: 2', 'Number: 3', 'Number: 4', 'Number: 5']
- * ```
- *
- * @example
- * ```typescript
- * // Transform objects with index
- * const users = [{ name: 'Alice' }, { name: 'Bob' }]
- * const indexed = mapArray(users, (user, index) => ({
- *   ...user,
- *   id: index + 1
- * }))
- * // Result: [{ name: 'Alice', id: 1 }, { name: 'Bob', id: 2 }]
- * ```
- *
- * @example
- * ```typescript
- * // Use with signals in Tempo
- * const items = prop([1, 2, 3])
- * const doubled = items.map(arr => mapArray(arr, n => n * 2))
- * ```
- *
- * @typeParam A - The type of elements in the input array
- * @typeParam B - The type of elements in the output array
- * @param arr - The input array to transform
- * @param f - Function that transforms each element (receives element and index)
- * @returns A new array with the transformed elements
- * @public
- */
-export declare const mapArray: <A, B>(arr: A[], f: (a: A, index: number) => B) => B[];
-/**
- * Transforms each element of an array into an array, then flattens all results into a single array.
- *
- * This function combines mapping and flattening operations. It applies a transformation function
- * to each element that returns an array, then concatenates all the resulting arrays into one.
- * This is useful for operations that need to expand elements into multiple items.
- *
- * @example
- * ```typescript
- * // Split strings and flatten
- * const sentences = ['hello world', 'foo bar', 'baz qux']
- * const words = flatMapArray(sentences, sentence => sentence.split(' '))
- * // Result: ['hello', 'world', 'foo', 'bar', 'baz', 'qux']
- * ```
- *
- * @example
- * ```typescript
- * // Expand objects into multiple items
- * const users = [
- *   { name: 'Alice', skills: ['JS', 'TS'] },
- *   { name: 'Bob', skills: ['Python', 'Go'] }
- * ]
- * const allSkills = flatMapArray(users, user =>
- *   user.skills.map(skill => ({ user: user.name, skill }))
- * )
- * // Result: [
- * //   { user: 'Alice', skill: 'JS' },
- * //   { user: 'Alice', skill: 'TS' },
- * //   { user: 'Bob', skill: 'Python' },
- * //   { user: 'Bob', skill: 'Go' }
- * // ]
- * ```
- *
- * @example
- * ```typescript
- * // Generate ranges
- * const ranges = [2, 3, 1]
- * const numbers = flatMapArray(ranges, n =>
- *   Array.from({ length: n }, (_, i) => i)
- * )
- * // Result: [0, 1, 0, 1, 2, 0]
- * ```
- *
- * @typeParam A - The type of elements in the input array
- * @typeParam B - The type of elements in the resulting flattened array
- * @param arr - The input array to transform and flatten
- * @param f - Function that transforms each element into an array
- * @returns A new flattened array containing all elements from the transformation results
- * @public
- */
-export declare const flatMapArray: <A, B>(arr: A[], f: (a: A) => B[]) => B[];
+import { Compare, Maybe, Nothing } from './domain';
 /**
  * Returns the first element of an array, or `undefined` if the array is empty.
  *
@@ -134,47 +43,6 @@ export declare const isArrayEmpty: <T>(arr: T[]) => arr is [];
  * @public
  */
 export declare const arrayHasValues: <T>(arr: T[]) => arr is [T, ...T[]];
-/**
- * Creates a new array containing only elements that satisfy the predicate function.
- *
- * This function provides a functional approach to filtering arrays, creating a new array
- * without modifying the original. Elements are included in the result only if the predicate
- * function returns `true` for that element.
- *
- * @example
- * ```typescript
- * // Filter even numbers
- * const numbers = [1, 2, 3, 4, 5, 6]
- * const evenNumbers = filterArray(numbers, n => n % 2 === 0)
- * // Result: [2, 4, 6]
- * ```
- *
- * @example
- * ```typescript
- * // Filter objects by property
- * const users = [
- *   { name: 'Alice', active: true },
- *   { name: 'Bob', active: false },
- *   { name: 'Charlie', active: true }
- * ]
- * const activeUsers = filterArray(users, user => user.active)
- * // Result: [{ name: 'Alice', active: true }, { name: 'Charlie', active: true }]
- * ```
- *
- * @example
- * ```typescript
- * // Use with signals in Tempo
- * const allItems = prop([1, 2, 3, 4, 5])
- * const evenItems = allItems.map(arr => filterArray(arr, n => n % 2 === 0))
- * ```
- *
- * @typeParam T - The type of elements in the array
- * @param arr - The array to filter
- * @param predicate - Function that tests each element (returns true to include the element)
- * @returns A new array containing only elements that satisfy the predicate
- * @public
- */
-export declare const filterArray: <T>(arr: T[], predicate: (v: T) => boolean) => T[];
 /**
  * Applies a mapping function to each element of an array and returns a new array
  * containing the mapped values, excluding any `null` or `undefined` values.
@@ -196,101 +64,6 @@ export declare const filterMapArray: <A, B>(arr: A[], f: (a: A, index: number) =
  * @public
  */
 export declare const filterNullsFromArray: <T>(arr: Array<T | Nothing>) => T[];
-/**
- * Flattens a two-dimensional array into a one-dimensional array.
- *
- * @param arr - The two-dimensional array to flatten.
- * @returns The flattened one-dimensional array.
- * @typeParam T - The type of elements in the array.
- * @public
- */
-export declare const flattenArray: <T>(arr: T[][]) => T[];
-/**
- * Reduces an array to a single value by applying an accumulator function from left to right.
- *
- * This function processes each element of the array in order, passing the current accumulator
- * value and the current element to the reducer function. The result becomes the new accumulator
- * value for the next iteration.
- *
- * @example
- * ```typescript
- * // Sum all numbers
- * const numbers = [1, 2, 3, 4, 5]
- * const sum = foldLeftArray(numbers, (acc, curr) => acc + curr, 0)
- * // Result: 15
- * ```
- *
- * @example
- * ```typescript
- * // Build an object from array
- * const items = ['apple', 'banana', 'cherry']
- * const indexed = foldLeftArray(
- *   items,
- *   (acc, item, index) => ({ ...acc, [index]: item }),
- *   {} as Record<number, string>
- * )
- * // Result: { 0: 'apple', 1: 'banana', 2: 'cherry' }
- * ```
- *
- * @example
- * ```typescript
- * // Count occurrences
- * const words = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
- * const counts = foldLeftArray(
- *   words,
- *   (acc, word) => ({ ...acc, [word]: (acc[word] || 0) + 1 }),
- *   {} as Record<string, number>
- * )
- * // Result: { apple: 3, banana: 2, cherry: 1 }
- * ```
- *
- * @typeParam T - The type of elements in the array
- * @typeParam B - The type of the accumulator value
- * @param arr - The array to reduce
- * @param f - Function that combines the accumulator with each element
- * @param b - The initial accumulator value
- * @returns The final accumulated result
- * @public
- */
-export declare const foldLeftArray: <T, B>(arr: T[], f: (acc: B, curr: T) => B, b: B) => B;
-/**
- * Checks if all elements in an array satisfy a given predicate.
- *
- * @param arr - The array to check.
- * @param predicate - The predicate function to apply to each element.
- * @returns `true` if all elements satisfy the predicate, `false` otherwise.
- * @typeParam T - The type of elements in the array.
- * @public
- */
-export declare const allElements: <T>(arr: T[], predicate: (v: T) => boolean) => boolean;
-/**
- * Checks if any element in the array satisfies the given predicate.
- *
- * @param arr - The array to check.
- * @param predicate - The predicate function to apply to each element.
- * @returns `true` if any element satisfies the predicate, `false` otherwise.
- * @typeParam T - The type of elements in the array.
- * @public
- */
-export declare const anyElement: <T>(arr: T[], predicate: (v: T) => boolean) => boolean;
-/**
- * Applies a function to each element in an array.
- *
- * @typeParam T - The type of elements in the array.
- * @param arr - The array to iterate over.
- * @param f - The function to apply to each element.
- * @public
- */
-export declare const forEachElement: <T>(arr: T[], f: (v: T) => void) => void;
-/**
- * Concatenates multiple arrays into a single array.
- *
- * @param arrs - The arrays to concatenate.
- * @returns The concatenated array.
- * @typeParam A - The type of elements in the arrays.
- * @public
- */
-export declare const concatArrays: <A>(...arrs: A[][]) => A[];
 /**
  * Compares two arrays based on their lengths and element values.
  *
@@ -303,81 +76,87 @@ export declare const concatArrays: <A>(...arrs: A[][]) => A[];
  * @public
  */
 export declare const compareArrays: <A>(a: A[], b: A[], comparef: Compare<A>, shorterFirst?: boolean) => number;
-/**
- * Sorts an array in place using the provided compare function.
- *
- * @typeParam A - The type of elements in the array.
- * @param arr - The array to be sorted.
- * @param compare - The compare function used to determine the order of the elements.
- * @returns The sorted array.
- * @public
- */
-export declare const sortArray: <A>(arr: A[], compare: Compare<A>) => A[];
 /**
  * Generates an array of values by applying a function to each index.
  *
+ * This function provides a more semantic alternative to `Array.from({ length }, (_, i) => f(i))`
+ * with better readability and intent expression. It's particularly useful for creating
+ * arrays with computed values based on their position.
+ *
+ * @example
+ * ```typescript
+ * // Create an array of squares
+ * const squares = buildArray(5, i => i * i)
+ * // Result: [0, 1, 4, 9, 16]
+ *
+ * // Create an array of objects with IDs
+ * const items = buildArray(3, i => ({ id: i, name: `Item ${i}` }))
+ * // Result: [{ id: 0, name: 'Item 0' }, { id: 1, name: 'Item 1' }, { id: 2, name: 'Item 2' }]
+ * ```
+ *
  * @param length - The length of the resulting array.
  * @param f - The function to apply to each index. It takes the index as a parameter and returns the corresponding value.
  * @returns An array of values generated by applying the function to each index.
  * @public
  */
-export declare const generateArray: <A>(length: number, f: (index: number) => A) => A[];
+export declare const buildArray: <A>(length: number, f: (index: number) => A) => A[];
 /**
- * Generates an array of numbers in a specified range.
+ * Generates an array of consecutive numbers in a specified range.
+ *
+ * This function provides a more intuitive API than `Array.from({ length }, (_, i) => startAt + i)`
+ * for creating numeric sequences. It's commonly needed for iterations, indexing, and mathematical operations.
+ *
+ * @example
+ * ```typescript
+ * // Create a range from 0 to 4
+ * const zeroToFour = range(5)
+ * // Result: [0, 1, 2, 3, 4]
+ *
+ * // Create a range from 10 to 14
+ * const tenToFourteen = range(5, 10)
+ * // Result: [10, 11, 12, 13, 14]
+ *
+ * // Use for creating test data
+ * const testIds = range(100, 1000)
+ * // Result: [1000, 1001, 1002, ..., 1099]
+ * ```
  *
  * @param length - The length of the array to generate.
  * @param startAt - The starting value of the range. Default is 0.
  * @returns An array of numbers in the specified range.
  * @public
  */
-export declare const generateSequenceArray: (length: number, startAt?: number) => number[];
+export declare const range: (length: number, startAt?: number) => number[];
 /**
  * Creates a new array with the specified length and fills it with the provided value.
  *
- * @typeParam A - The type of the elements in the array.
- * @param length - The length of the new array.
- * @param value - The value to fill the array with.
- * @returns A new array filled with the specified value.
- * @public
- */
-export declare const createFilledArray: <A>(length: number, value: A) => A[];
-/**
- * Removes duplicate primitive values from an array, returning only unique values.
- *
- * This function uses JavaScript's Set to efficiently remove duplicates from arrays
- * containing primitive values (strings, numbers, booleans, symbols). The order of
- * first occurrence is preserved.
+ * This function provides a more semantic alternative to `Array(length).fill(value)` or
+ * `new Array(length).fill(value)` with better type inference and clearer intent.
+ * It's particularly useful when you need arrays of non-primitive values or when
+ * working with functional programming patterns.
  *
  * @example
  * ```typescript
- * // Remove duplicate numbers
- * const numbers = [1, 2, 2, 3, 1, 4, 3]
- * const unique = uniquePrimitives(numbers)
- * // Result: [1, 2, 3, 4]
- * ```
+ * // Create an array of default objects
+ * const defaultUsers = fillArray(3, { name: '', active: false })
+ * // Result: [{ name: '', active: false }, { name: '', active: false }, { name: '', active: false }]
  *
- * @example
- * ```typescript
- * // Remove duplicate strings
- * const tags = ['react', 'vue', 'react', 'angular', 'vue']
- * const uniqueTags = uniquePrimitives(tags)
- * // Result: ['react', 'vue', 'angular']
- * ```
+ * // Create an array of empty arrays
+ * const matrix = fillArray(3, [] as number[])
+ * // Result: [[], [], []]
  *
- * @example
- * ```typescript
- * // Mixed primitive types
- * const mixed = [1, '1', true, 1, 'hello', true, '1']
- * const uniqueMixed = uniquePrimitives(mixed)
- * // Result: [1, '1', true, 'hello']
+ * // Create an array of functions
+ * const handlers = fillArray(5, () => console.log('handler'))
+ * // Result: [function, function, function, function, function]
  * ```
  *
- * @typeParam T - The type of primitive elements in the array
- * @param values - The input array containing primitive values
- * @returns A new array with duplicate values removed, preserving order of first occurrence
+ * @typeParam A - The type of the elements in the array.
+ * @param length - The length of the new array.
+ * @param value - The value to fill the array with.
+ * @returns A new array filled with the specified value.
  * @public
  */
-export declare const uniquePrimitives: <T extends Primitive>(values: T[]) => T[];
+export declare const fillArray: <A>(length: number, value: A) => A[];
 /**
  * Removes duplicate objects from an array based on a key extraction function.
  *
@@ -483,14 +262,6 @@ export declare const removeOneFromArrayByPredicate: <A>(arr: A[], predicate: (a:
  * @public
  */
 export declare const removeAllFromArrayByPredicate: <A>(arr: A[], predicate: (a: A) => boolean) => boolean;
-/**
- * Converts an IterableIterator to an array.
- *
- * @param it - The IterableIterator to convert.
- * @returns An array containing the values from the IterableIterator.
- * @public
- */
-export declare const arrayOfIterableIterator: <A>(it: IterableIterator<A>) => A[];
 /**
  * Represents the different operations that can be performed on an array.
  *
@@ -555,3 +326,72 @@ export declare const joinArrayWithConjunction: <A>(arr: A[], conjunction?: strin
  * @public
  */
 export declare const rankArray: <T>(array: T[], compare: (a: T, b: T) => number, incrementDuplicates?: boolean) => number[];
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * This function divides an array into smaller arrays of a fixed size.
+ * The last chunk may contain fewer elements if the array length is not
+ * evenly divisible by the chunk size.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * const chunks = chunk(numbers, 3)
+ * // Result: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+ *
+ * const uneven = chunk([1, 2, 3, 4, 5], 2)
+ * // Result: [[1, 2], [3, 4], [5]]
+ * ```
+ *
+ * @param array - The array to chunk
+ * @param size - The size of each chunk (must be positive)
+ * @returns An array of chunks
+ * @public
+ */
+export declare const chunk: <T>(array: readonly T[], size: number) => T[][];
+/**
+ * Partitions an array into two arrays based on a predicate.
+ *
+ * This function splits an array into two parts: elements that satisfy
+ * the predicate and elements that don't. The order of elements is preserved.
+ *
+ * @example
+ * ```typescript
+ * const numbers = [1, 2, 3, 4, 5, 6]
+ * const [evens, odds] = partition(numbers, n => n % 2 === 0)
+ * // evens: [2, 4, 6]
+ * // odds: [1, 3, 5]
+ * ```
+ *
+ * @param array - The array to partition
+ * @param predicate - Function that tests each element
+ * @returns A tuple containing [matching elements, non-matching elements]
+ * @public
+ */
+export declare const partition: <T>(array: readonly T[], predicate: (item: T) => boolean) => [T[], T[]];
+/**
+ * Groups array elements by a key function.
+ *
+ * This function creates an object where keys are the result of the key function
+ * and values are arrays of elements that produced that key.
+ *
+ * @example
+ * ```typescript
+ * const users = [
+ *   { name: 'Alice', department: 'Engineering' },
+ *   { name: 'Bob', department: 'Engineering' },
+ *   { name: 'Carol', department: 'Marketing' }
+ * ]
+ * const byDepartment = groupBy(users, user => user.department)
+ * // Result: {
+ * //   Engineering: [{ name: 'Alice', ... }, { name: 'Bob', ... }],
+ * //   Marketing: [{ name: 'Carol', ... }]
+ * // }
+ * ```
+ *
+ * @param array - The array to group
+ * @param keyFn - Function that extracts the grouping key from each element
+ * @returns An object with grouped elements
+ * @public
+ */
+export declare const groupBy: <T, K extends string | number | symbol>(array: readonly T[], keyFn: (item: T) => K) => Record<K, T[]>;