@elaraai/east 0.0.1-beta.0

package/dist/src/expr/array.js

@@ -0,0 +1,1805 @@
+import { get_location } from "../location.js";
+import { ArrayType, BooleanType, FunctionType, IntegerType, NullType, StringType, isSubtype, isTypeEqual, printType, NeverType, OptionType, isDataType, StructType, VariantType, SetType, FloatType, DictType } from "../types.js";
+import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
+import { AstSymbol, Expr, FactorySymbol, TypeSymbol } from "./expr.js";
+import { none, some } from "../containers/variant.js";
+/**
+ * Expression representing mutable array values and operations.
+ *
+ * ArrayExpr provides comprehensive methods for array manipulation including element access,
+ * mutation (push/pop/sort/reverse), transformation (map/filter/reduce), searching, slicing,
+ * grouping, and aggregation. Arrays are mutable, ordered collections with zero-based indexing.
+ *
+ * @example
+ * ```ts
+ * // Array manipulation
+ * const processArray = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+ *   $(arr.pushLast(10n));  // Mutate: add element
+ *   const doubled = arr.map(($, x, i) => x.multiply(2n));
+ *   $.return(doubled);
+ * });
+ *
+ * // Filtering and mapping
+ * const filterMap = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+ *   const evens = arr.filter(($, x, i) => x.remainder(2n).equal(0n));
+ *   $.return(evens.map(($, x, i) => x.add(1n)));
+ * });
+ *
+ * // Aggregation
+ * const sumArray = East.function([ArrayType(IntegerType)], IntegerType, ($, arr) => {
+ *   $.return(arr.reduce(($, acc, x, i) => acc.add(x), 0n));
+ * });
+ * ```
+ */
+export class ArrayExpr extends Expr {
+    value_type;
+    constructor(value_type, ast, createExpr) {
+        super(ast.type, ast, createExpr);
+        this.value_type = value_type;
+    }
+    /**
+     * Returns the size (length) of the array.
+     *
+     * @returns An IntegerExpr representing the number of elements
+     *
+     * @example
+     * ```ts
+     * const getSize = East.function([ArrayType(IntegerType)], IntegerType, ($, arr) => {
+     *   $.return(arr.size());
+     * });
+     * const compiled = East.compile(getSize.toIR(), []);
+     * compiled([1n, 2n, 3n]);  // 3n
+     * compiled([]);            // 0n
+     * ```
+     */
+    size() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "ArraySize",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Checks if an element exists at the specified index (i.e., if the index is in bounds).
+     *
+     * @param key - The zero-based index to check
+     * @returns A BooleanExpr that is true if the index is valid (0 <= index < size)
+     *
+     * @example
+     * ```ts
+     * const hasElement = East.function([ArrayType(IntegerType), IntegerType], BooleanType, ($, arr, index) => {
+     *   $.return(arr.has(index));
+     * });
+     * const compiled = East.compile(hasElement.toIR(), []);
+     * compiled([10n, 20n, 30n], 1n);   // true
+     * compiled([10n, 20n, 30n], 5n);   // false
+     * compiled([10n, 20n, 30n], -1n);  // false
+     * ```
+     */
+    has(key) {
+        const keyAst = valueOrExprToAstTyped(key, IntegerType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "ArrayHas",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Gets the element at the specified index.
+     *
+     * @param key - The zero-based index
+     * @param defaultFn - Optional function to provide a default value for out-of-bounds indices
+     * @returns An expression of the array's element type
+     *
+     * @throws East runtime error if index is out of bounds and no defaultFn is provided
+     *
+     * @example
+     * ```ts
+     * const getElement = East.function([ArrayType(IntegerType), IntegerType], IntegerType, ($, arr, index) => {
+     *   $.return(arr.get(index));
+     * });
+     * const compiled = East.compile(getElement.toIR(), []);
+     * compiled([10n, 20n, 30n], 1n);  // 20n
+     * // compiled([10n, 20n, 30n], 5n) would throw error
+     *
+     * // With default value
+     * const getOrDefault = East.function([ArrayType(IntegerType), IntegerType], IntegerType, ($, arr, index) => {
+     *   $.return(arr.get(index, ($, i) => -1n));
+     * });
+     * compiled = East.compile(getOrDefault.toIR(), []);
+     * compiled([10n, 20n, 30n], 5n);  // -1n (out of bounds)
+     * ```
+     */
+    get(key, defaultFn) {
+        const keyAst = valueOrExprToAstTyped(key, IntegerType);
+        if (defaultFn !== undefined) {
+            const defaultFnAst = valueOrExprToAstTyped(defaultFn, FunctionType([IntegerType], this.value_type, null));
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: this.value_type,
+                location: get_location(2),
+                builtin: "ArrayGetOrDefault",
+                type_parameters: [this.value_type],
+                arguments: [this[AstSymbol], keyAst, defaultFnAst],
+            });
+        }
+        else {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: this.value_type,
+                location: get_location(2),
+                builtin: "ArrayGet",
+                type_parameters: [this.value_type],
+                arguments: [this[AstSymbol], keyAst],
+            });
+        }
+    }
+    /**
+     * Safely gets the element at the specified index, returning an Option variant.
+     *
+     * @param key - The zero-based index
+     * @returns An OptionType expression containing .some(value) if in bounds, or .none if out of bounds
+     *
+     * @example
+     * ```ts
+     * const tryGetElement = East.function([ArrayType(IntegerType), IntegerType], OptionType(IntegerType), ($, arr, index) => {
+     *   $.return(arr.tryGet(index));
+     * });
+     * const compiled = East.compile(tryGetElement.toIR(), []);
+     * compiled([10n, 20n, 30n], 1n);  // {_tag: "some", some: 20n}
+     * compiled([10n, 20n, 30n], 5n);  // {_tag: "none", none: null}
+     * ```
+     */
+    tryGet(key) {
+        const keyAst = valueOrExprToAstTyped(key, IntegerType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: OptionType(this.value_type),
+            location: get_location(2),
+            builtin: "ArrayTryGet",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Updates (replaces) the element at the specified index (mutates the array).
+     *
+     * @param key - The zero-based index to update
+     * @param value - The new value to set at that index
+     * @returns NullExpr (operation performed for side effect)
+     *
+     * @throws East runtime error if index is out of bounds
+     *
+     * @example
+     * ```ts
+     * const updateElement = East.function([ArrayType(IntegerType), IntegerType, IntegerType], ArrayType(IntegerType), ($, arr, index, value) => {
+     *   $(arr.update(index, value));  // Mutate the array
+     *   $.return(arr);
+     * });
+     * const compiled = East.compile(updateElement.toIR(), []);
+     * compiled([10n, 20n, 30n], 1n, 99n);  // [10n, 99n, 30n]
+     * ```
+     */
+    update(key, value) {
+        const keyAst = valueOrExprToAstTyped(key, IntegerType);
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayUpdate",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], keyAst, valueAst],
+        });
+    }
+    /** Modify an array element at index by merging it with a new value using a function accepting the new and current value. An error is thrown on missing key (index out of bounds).
+     *
+     * This is useful for patterns where you want to update an element based on its current value, e.g. incrementing a number, appending to a string, updating fields in a struct, or pushing to an array.
+     *
+     * @see {@link update} for simply replacing the value.
+     */
+    merge(key, value, updateFn) {
+        const location = get_location(2);
+        const keyAst = valueOrExprToAstTyped(key, IntegerType);
+        const value2Type = value[TypeSymbol];
+        const updateFnExpr = Expr.from(updateFn, FunctionType([value2Type, this.value_type, IntegerType], this.value_type, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location,
+            builtin: "ArrayMerge",
+            type_parameters: [this.value_type, value2Type],
+            arguments: [this[AstSymbol], keyAst, value[AstSymbol], updateFnExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Adds an element to the end of the array (mutates the array).
+     *
+     * @param value - The value to append
+     * @returns NullExpr (operation performed for side effect)
+     *
+     * @example
+     * ```ts
+     * const appendValue = East.function([ArrayType(IntegerType), IntegerType], ArrayType(IntegerType), ($, arr, value) => {
+     *   $(arr.pushLast(value));  // Mutate the array
+     *   $.return(arr);
+     * });
+     * const compiled = East.compile(appendValue.toIR(), []);
+     * compiled([1n, 2n, 3n], 4n);  // [1n, 2n, 3n, 4n]
+     * ```
+     */
+    pushLast(value) {
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayPushLast",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], valueAst],
+        });
+    }
+    /**
+     * Removes and returns the last element from the array (mutates the array).
+     *
+     * @returns An expression of the array's element type containing the removed value
+     *
+     * @throws East runtime error if the array is empty
+     *
+     * @example
+     * ```ts
+     * const removeLastValue = East.function([ArrayType(IntegerType)], IntegerType, ($, arr) => {
+     *   $.return(arr.popLast());
+     * });
+     * const compiled = East.compile(removeLastValue.toIR(), []);
+     * compiled([1n, 2n, 3n]);  // 3n (arr is now [1n, 2n])
+     * ```
+     */
+    popLast() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this.value_type,
+            location: get_location(2),
+            builtin: "ArrayPopLast",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Adds an element to the beginning of the array (mutates the array).
+     *
+     * @param value - The value to prepend
+     * @returns NullExpr (operation performed for side effect)
+     *
+     * @example
+     * ```ts
+     * const prependValue = East.function([ArrayType(IntegerType), IntegerType], ArrayType(IntegerType), ($, arr, value) => {
+     *   $(arr.pushFirst(value));  // Mutate the array
+     *   $.return(arr);
+     * });
+     * const compiled = East.compile(prependValue.toIR(), []);
+     * compiled([1n, 2n, 3n], 0n);  // [0n, 1n, 2n, 3n]
+     * ```
+     */
+    pushFirst(value) {
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayPushFirst",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], valueAst],
+        });
+    }
+    /**
+     * Removes and returns the first element from the array (mutates the array).
+     *
+     * @returns An expression of the array's element type containing the removed value
+     *
+     * @throws East runtime error if the array is empty
+     *
+     * @example
+     * ```ts
+     * const removeFirstValue = East.function([ArrayType(IntegerType)], IntegerType, ($, arr) => {
+     *   $.return(arr.popFirst());
+     * });
+     * const compiled = East.compile(removeFirstValue.toIR(), []);
+     * compiled([1n, 2n, 3n]);  // 1n (arr is now [2n, 3n])
+     * ```
+     */
+    popFirst() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this.value_type,
+            location: get_location(2),
+            builtin: "ArrayPopFirst",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Appends all elements from another array to this array (mutates the array).
+     *
+     * @param array - The array whose elements will be appended
+     * @returns NullExpr (operation performed for side effect)
+     *
+     * @example
+     * ```ts
+     * const appendArray = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr1, arr2) => {
+     *   $(arr1.append(arr2));  // Mutate arr1
+     *   $.return(arr1);
+     * });
+     * const compiled = East.compile(appendArray.toIR(), []);
+     * compiled([1n, 2n], [3n, 4n]);  // [1n, 2n, 3n, 4n]
+     * ```
+     */
+    append(array) {
+        const arrayExpr = Expr.from(array, this[TypeSymbol]);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayAppend",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], arrayExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Prepends all elements from another array to this array (mutates the array).
+     *
+     * @param array - The array whose elements will be prepended
+     * @returns NullExpr (operation performed for side effect)
+     *
+     * @example
+     * ```ts
+     * const prependArray = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr1, arr2) => {
+     *   $(arr1.prepend(arr2));  // Mutate arr1
+     *   $.return(arr1);
+     * });
+     * const compiled = East.compile(prependArray.toIR(), []);
+     * compiled([3n, 4n], [1n, 2n]);  // [1n, 2n, 3n, 4n]
+     * ```
+     */
+    prepend(array) {
+        // Convert the input array to an expression of the right type
+        const arrayExpr = Expr.from(array, this[TypeSymbol]);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayPrepend",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], arrayExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Merges all elements from another array into this array using a merge function.
+     *
+     * @param array - The array to merge from
+     * @param mergeFn - Function taking (currentValue, otherValue, index) and returning the merged value
+     * @returns Null (mutates the array in place)
+     *
+     * @throws East runtime error if the other array has more elements than this array
+     *
+     * @example
+     * ```ts
+     * const mergeArrays = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], NullType, ($, arr1, arr2) => {
+     *   arr1.mergeAll(arr2, ($, current, other, index) => current.add(other));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(mergeArrays.toIR(), []);
+     * const arr1 = [10n, 20n, 30n];
+     * const arr2 = [1n, 2n, 3n];
+     * compiled(arr1, arr2);  // null (arr1 is now [11n, 22n, 33n])
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Combining strings
+     * const mergeStrings = East.function([ArrayType(StringType), ArrayType(StringType)], ArrayType(StringType), ($, arr1, arr2) => {
+     *   arr1.mergeAll(arr2, ($, current, other, index) => current.concat(" + ").concat(other));
+     *   $.return(arr1);
+     * });
+     * const compiled = East.compile(mergeStrings.toIR(), []);
+     * compiled(["a", "b"], ["x", "y"]);  // ["a + x", "b + y"]
+     * ```
+     */
+    mergeAll(array, mergeFn) {
+        const array_type = array[TypeSymbol];
+        if (!array_type || array_type.type !== "Array") {
+            throw new Error(`Expected array type for mergeAll, got ${array_type ? printType(array_type) : "unknown"}`);
+        }
+        const value2Type = array_type.value;
+        const mergeFnExpr = Expr.from(mergeFn, FunctionType([this.value_type, value2Type, IntegerType], this.value_type, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayMergeAll",
+            type_parameters: [this.value_type, value2Type],
+            arguments: [this[AstSymbol], array[AstSymbol], mergeFnExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Clears all elements from the array, making it empty.
+     *
+     * @returns Null (mutates the array in place)
+     *
+     * @example
+     * ```ts
+     * const clearArray = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+     *   arr.clear();
+     *   $.return(arr);
+     * });
+     * const compiled = East.compile(clearArray.toIR(), []);
+     * compiled([1n, 2n, 3n]);  // []
+     * ```
+     */
+    clear() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayClear",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Sorts the array in place, re-ordering it in memory.
+     *
+     * @param by - Optional projection function to determine sort order (defaults to sorting by the values themselves)
+     * @returns Null (mutates the array in place)
+     *
+     * @remarks
+     * The optional `by` function can project values to determine sort order (e.g., sort by a specific field).
+     *
+     * @example
+     * ```ts
+     * const sortNumbers = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+     *   arr.sortInPlace();
+     *   $.return(arr);
+     * });
+     * const compiled = East.compile(sortNumbers.toIR(), []);
+     * compiled([3n, 1n, 4n, 1n, 5n]);  // [1n, 1n, 3n, 4n, 5n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Sorting structs by a field
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const sortByAge = East.function([ArrayType(PersonType)], ArrayType(PersonType), ($, people) => {
+     *   people.sortInPlace(($, p) => p.age);
+     *   $.return(people);
+     * });
+     * const compiled = East.compile(sortByAge.toIR(), []);
+     * compiled([{ name: "Alice", age: 30n }, { name: "Bob", age: 25n }]);
+     * // [{ name: "Bob", age: 25n }, { name: "Alice", age: 30n }]
+     * ```
+     *
+     * @see {@link sort} to produce a new sorted array instead of sorting in place.
+     */
+    sortInPlace(by) {
+        let byExpr;
+        if (by === undefined) {
+            byExpr = Expr.function([this.value_type], this.value_type, ($, x) => x);
+        }
+        else {
+            byExpr = by instanceof Expr ? by : Expr.function([this.value_type], undefined, by);
+        }
+        const byType = byExpr[TypeSymbol];
+        const projectedType = byType.output;
+        if (!(isDataType(projectedType))) {
+            throw new Error(`Can only sort by data types, got ${printType(projectedType)}`);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArraySortInPlace",
+            type_parameters: [this.value_type, projectedType],
+            arguments: [this[AstSymbol], byExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Produces a new array with the values sorted.
+     *
+     * @param by - Optional projection function to determine sort order (defaults to sorting by the values themselves)
+     * @returns A new ArrayExpr containing the sorted elements
+     *
+     * @remarks
+     * The optional `by` function can project values to determine sort order (e.g., sort by a specific field).
+     * This method does not mutate the original array.
+     *
+     * @example
+     * ```ts
+     * const sortNumbers = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+     *   $.return(arr.sort());
+     * });
+     * const compiled = East.compile(sortNumbers.toIR(), []);
+     * compiled([3n, 1n, 4n, 1n, 5n]);  // [1n, 1n, 3n, 4n, 5n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Sorting structs by a field (descending)
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const sortByAgeDesc = East.function([ArrayType(PersonType)], ArrayType(PersonType), ($, people) => {
+     *   $.return(people.sort(($, p) => p.age.negate()));
+     * });
+     * const compiled = East.compile(sortByAgeDesc.toIR(), []);
+     * compiled([{ name: "Alice", age: 30n }, { name: "Bob", age: 25n }]);
+     * // [{ name: "Alice", age: 30n }, { name: "Bob", age: 25n }]
+     * ```
+     *
+     * @see {@link sortInPlace} to sort the array in place.
+     */
+    sort(by) {
+        let byExpr;
+        if (by === undefined) {
+            byExpr = Expr.function([this.value_type], this.value_type, ($, x) => x);
+        }
+        else {
+            byExpr = by instanceof Expr ? by : Expr.function([this.value_type], undefined, by);
+        }
+        const byType = byExpr[TypeSymbol];
+        const projectedType = byType.output;
+        if (!(isDataType(projectedType))) {
+            throw new Error(`Can only sort by data types, got ${printType(projectedType)}`);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "ArraySort",
+            type_parameters: [this.value_type, projectedType],
+            arguments: [this[AstSymbol], byExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Reverses the array in place.
+     *
+     * @returns Null (mutates the array in place)
+     *
+     * @example
+     * ```ts
+     * const reverseArray = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+     *   arr.reverseInPlace();
+     *   $.return(arr);
+     * });
+     * const compiled = East.compile(reverseArray.toIR(), []);
+     * compiled([1n, 2n, 3n, 4n, 5n]);  // [5n, 4n, 3n, 2n, 1n]
+     * ```
+     *
+     * @see {@link reverse} to produce a new reversed array instead of reversing in place.
+     */
+    reverseInPlace() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayReverseInPlace",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Produces a new array with the values in reverse order.
+     *
+     * @returns A new ArrayExpr with elements in reverse order
+     *
+     * @remarks
+     * This method does not mutate the original array.
+     *
+     * @example
+     * ```ts
+     * const reverseArray = East.function([ArrayType(StringType)], ArrayType(StringType), ($, arr) => {
+     *   $.return(arr.reverse());
+     * });
+     * const compiled = East.compile(reverseArray.toIR(), []);
+     * compiled(["a", "b", "c"]);  // ["c", "b", "a"]
+     * ```
+     *
+     * @see {@link reverseInPlace} to reverse the array in place.
+     */
+    reverse() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "ArrayReverse",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Checks if the array is sorted in ascending order.
+     *
+     * @param by - Optional projection function to determine sort order (defaults to sorting by the values themselves)
+     * @returns A BooleanExpr indicating whether the array is sorted
+     *
+     * @example
+     * ```ts
+     * const checkSorted = East.function([ArrayType(IntegerType)], BooleanType, ($, arr) => {
+     *   $.return(arr.isSorted());
+     * });
+     * const compiled = East.compile(checkSorted.toIR(), []);
+     * compiled([1n, 2n, 3n, 4n]);  // true
+     * compiled([1n, 3n, 2n, 4n]);  // false
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Checking if sorted by a specific field
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const checkSortedByAge = East.function([ArrayType(PersonType)], BooleanType, ($, people) => {
+     *   $.return(people.isSorted(($, p) => p.age));
+     * });
+     * const compiled = East.compile(checkSortedByAge.toIR(), []);
+     * compiled([{ name: "Bob", age: 25n }, { name: "Alice", age: 30n }]);  // true
+     * ```
+     */
+    isSorted(by) {
+        let byExpr;
+        if (by === undefined) {
+            byExpr = Expr.function([this.value_type], this.value_type, ($, x) => x);
+        }
+        else {
+            byExpr = by instanceof Expr ? by : Expr.function([this.value_type], undefined, by);
+        }
+        const byType = byExpr[TypeSymbol];
+        const projectedType = byType.output;
+        if (!(isDataType(projectedType))) {
+            throw new Error(`Can only sort by data types, got ${printType(projectedType)}`);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "ArrayIsSorted",
+            type_parameters: [this.value_type, projectedType],
+            arguments: [this[AstSymbol], byExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the index of the first element in a sorted array that is >= the given value (binary search).
+     *
+     * @param value - The value to search for
+     * @param by - Optional projection function used for sorting (must match the array's sort order)
+     * @returns An IntegerExpr representing the index (may be out of bounds if all elements are less)
+     *
+     * @remarks
+     * This method assumes the array is already sorted. If all elements are less than the given value,
+     * the returned index will equal the array size (out-of-bounds).
+     *
+     * @example
+     * ```ts
+     * const findFirst = East.function([ArrayType(IntegerType), IntegerType], IntegerType, ($, arr, value) => {
+     *   $.return(arr.findSortedFirst(value));
+     * });
+     * const compiled = East.compile(findFirst.toIR(), []);
+     * compiled([1n, 3n, 5n, 7n, 9n], 5n);  // 2n (index of 5)
+     * compiled([1n, 3n, 5n, 7n, 9n], 4n);  // 2n (index where 4 would be inserted)
+     * compiled([1n, 3n, 5n, 7n, 9n], 10n); // 5n (out of bounds)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Using with projection function
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const findByAge = East.function([ArrayType(PersonType), IntegerType], IntegerType, ($, people, age) => {
+     *   $.return(people.findSortedFirst(age, ($, p) => p.age));
+     * });
+     * const compiled = East.compile(findByAge.toIR(), []);
+     * // Assumes people array is sorted by age
+     * compiled([{ name: "Bob", age: 25n }, { name: "Alice", age: 30n }], 28n); // 1n
+     * ```
+     */
+    findSortedFirst(value, by) {
+        const valueAst = valueOrExprToAst(value);
+        const projectedType = valueAst.type;
+        if (!isDataType(projectedType)) {
+            throw new Error(`Can only search for data types, got ${printType(projectedType)}`);
+        }
+        let byExpr;
+        if (by === undefined) {
+            // It would be cool to infer an "obvious" projection here, e.g. prefix of a struct
+            byExpr = Expr.function([this.value_type], projectedType, ($, x) => x);
+        }
+        else {
+            byExpr = by instanceof Expr ? by : Expr.function([this.value_type], projectedType, by);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "ArrayFindSortedFirst",
+            type_parameters: [this.value_type, projectedType],
+            arguments: [this[AstSymbol], valueAst, byExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the index of the last element in a sorted array that is <= the given value (binary search).
+     *
+     * @param value - The value to search for
+     * @param by - Optional projection function used for sorting (must match the array's sort order)
+     * @returns An IntegerExpr representing the index (may be -1 if all elements are greater)
+     *
+     * @remarks
+     * This method assumes the array is already sorted. If all elements are greater than the given value,
+     * the returned index will be -1 (out-of-bounds).
+     *
+     * @example
+     * ```ts
+     * const findLast = East.function([ArrayType(IntegerType), IntegerType], IntegerType, ($, arr, value) => {
+     *   $.return(arr.findSortedLast(value));
+     * });
+     * const compiled = East.compile(findLast.toIR(), []);
+     * compiled([1n, 3n, 5n, 7n, 9n], 5n);  // 2n (index of 5)
+     * compiled([1n, 3n, 5n, 7n, 9n], 6n);  // 2n (index of last element <= 6)
+     * compiled([1n, 3n, 5n, 7n, 9n], 0n);  // -1n (all elements are greater)
+     * ```
+     */
+    findSortedLast(value, by) {
+        const valueAst = valueOrExprToAst(value);
+        const projectedType = valueAst.type;
+        if (!isDataType(projectedType)) {
+            throw new Error(`Can only search for data types, got ${printType(projectedType)}`);
+        }
+        let byExpr;
+        if (by === undefined) {
+            // It would be cool to infer an "obvious" projection here, e.g. prefix of a struct
+            byExpr = Expr.function([this.value_type], projectedType, ($, x) => x);
+        }
+        else {
+            byExpr = by instanceof Expr ? by : Expr.function([this.value_type], projectedType, by);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "ArrayFindSortedLast",
+            type_parameters: [this.value_type, projectedType],
+            arguments: [this[AstSymbol], valueAst, byExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Returns the start and end indices of elements in a sorted array that equal the given value (binary search).
+     *
+     * @param value - The value to search for
+     * @param by - Optional projection function used for sorting (must match the array's sort order)
+     * @returns A struct with `start` and `end` indices (exclusive end, may be out of bounds if not found)
+     *
+     * @remarks
+     * This method assumes the array is already sorted. If no elements match, the range will have zero size.
+     * The indices may be out-of-bounds if no elements are found.
+     *
+     * @example
+     * ```ts
+     * const findRange = East.function([ArrayType(IntegerType), IntegerType], StructType({ start: IntegerType, end: IntegerType }), ($, arr, value) => {
+     *   $.return(arr.findSortedRange(value));
+     * });
+     * const compiled = East.compile(findRange.toIR(), []);
+     * compiled([1n, 3n, 5n, 5n, 5n, 7n, 9n], 5n);  // { start: 2n, end: 5n }
+     * compiled([1n, 3n, 5n, 7n, 9n], 4n);          // { start: 2n, end: 2n } (not found)
+     * ```
+     */
+    findSortedRange(value, by) {
+        const valueAst = valueOrExprToAst(value);
+        const projectedType = valueAst.type;
+        if (!isDataType(projectedType)) {
+            throw new Error(`Can only search for data types, got ${printType(projectedType)}`);
+        }
+        let byExpr;
+        if (by === undefined) {
+            // It would be cool to infer an "obvious" projection here, e.g. prefix of a struct
+            byExpr = Expr.function([this.value_type], projectedType, ($, x) => x);
+        }
+        else {
+            byExpr = by instanceof Expr ? by : Expr.function([this.value_type], projectedType, by);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: StructType({ start: IntegerType, end: IntegerType }),
+            location: get_location(2),
+            builtin: "ArrayFindSortedRange",
+            type_parameters: [this.value_type, projectedType],
+            arguments: [this[AstSymbol], valueAst, byExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Extracts a slice of the array from start to end index (exclusive).
+     *
+     * @param start - The starting index (inclusive)
+     * @param end - The ending index (exclusive)
+     * @returns A new ArrayExpr containing the sliced elements
+     *
+     * @remarks
+     * This method does not mutate the original array.
+     *
+     * @example
+     * ```ts
+     * const sliceArray = East.function([ArrayType(IntegerType), IntegerType, IntegerType], ArrayType(IntegerType), ($, arr, start, end) => {
+     *   $.return(arr.slice(start, end));
+     * });
+     * const compiled = East.compile(sliceArray.toIR(), []);
+     * compiled([10n, 20n, 30n, 40n, 50n], 1n, 4n);  // [20n, 30n, 40n]
+     * compiled([10n, 20n, 30n, 40n, 50n], 0n, 2n);  // [10n, 20n]
+     * ```
+     */
+    slice(start, end) {
+        const startExpr = Expr.from(start, IntegerType);
+        const endExpr = Expr.from(end, IntegerType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "ArraySlice",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], startExpr[AstSymbol], endExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Creates a new array containing values from this array followed by values of the other array.
+     *
+     * @param other - The array to concatenate
+     * @returns A new ArrayExpr with combined elements
+     *
+     * @remarks
+     * This method does not mutate the original arrays.
+     *
+     * @example
+     * ```ts
+     * const concatArrays = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr1, arr2) => {
+     *   $.return(arr1.concat(arr2));
+     * });
+     * const compiled = East.compile(concatArrays.toIR(), []);
+     * compiled([1n, 2n, 3n], [4n, 5n]);  // [1n, 2n, 3n, 4n, 5n]
+     * ```
+     */
+    concat(other) {
+        const otherExpr = Expr.from(other, this[TypeSymbol]);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "ArrayConcat",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], otherExpr[AstSymbol]],
+        });
+    }
+    /**
+     * Returns a new array containing values at the specified indices.
+     *
+     * @param keys - An array of indices to retrieve
+     * @param onMissing - Optional function to provide default values for out-of-bounds indices
+     * @returns A new ArrayExpr with elements at the specified indices
+     *
+     * @throws East runtime error if an index is out of bounds and no onMissing function is provided
+     *
+     * @example
+     * ```ts
+     * const getMultiple = East.function([ArrayType(StringType), ArrayType(IntegerType)], ArrayType(StringType), ($, arr, indices) => {
+     *   $.return(arr.getKeys(indices));
+     * });
+     * const compiled = East.compile(getMultiple.toIR(), []);
+     * compiled(["a", "b", "c", "d"], [0n, 2n, 3n]);  // ["a", "c", "d"]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // With default for missing keys
+     * const getWithDefault = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr, indices) => {
+     *   $.return(arr.getKeys(indices, ($, key) => -1n));
+     * });
+     * const compiled = East.compile(getWithDefault.toIR(), []);
+     * compiled([10n, 20n, 30n], [1n, 5n, 2n]);  // [20n, -1n, 30n]
+     * ```
+     */
+    getKeys(keys, onMissing) {
+        const keysExpr = Expr.from(keys, ArrayType(IntegerType));
+        let default_function_ast;
+        if (onMissing === undefined) {
+            const location = get_location(2);
+            const default_function = Expr.function([IntegerType], this.value_type, ($, key) => $.error(Expr.str `Cannot get key ${key} from array`, location));
+            default_function_ast = Expr.ast(default_function);
+        }
+        else {
+            const default_function_expr = Expr.from(onMissing, FunctionType([IntegerType], this.value_type, null));
+            default_function_ast = Expr.ast(default_function_expr);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "ArrayGetKeys",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol], keysExpr[AstSymbol], default_function_ast],
+        });
+    }
+    /**
+     * Executes a function for each element in the array.
+     *
+     * @param fn - Function taking (element, index) to execute for each entry
+     * @returns Null
+     *
+     * @example
+     * ```ts
+     * const log = East.platform(FunctionType([StringType], NullType));
+     * const forEachExample = East.function([ArrayType(IntegerType)], NullType, ($, arr) => {
+     *   arr.forEach(($, elem, index) => {
+     *     log(Expr.str`Index ${index}: ${elem}`);
+     *   });
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(forEachExample.toIR(), [log.implement(console.log)]);
+     * compiled([10n, 20n, 30n]);
+     * // Logs: "Index 0: 10", "Index 1: 20", "Index 2: 30"
+     * ```
+     */
+    forEach(fn) {
+        if (!(fn instanceof Expr)) {
+            fn = Expr.function([this.value_type, IntegerType], undefined, fn);
+        }
+        const fnType = fn[TypeSymbol];
+        const returnType = fnType.output;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "ArrayForEach",
+            type_parameters: [this.value_type, returnType],
+            arguments: [this[AstSymbol], fn[AstSymbol]],
+        });
+    }
+    /**
+     * Creates a shallow copy of the array.
+     *
+     * @returns A new ArrayExpr with the same elements
+     *
+     * @remarks
+     * Only the top-level array is cloned. Deeply nested structures (e.g., arrays of arrays) share references.
+     *
+     * @example
+     * ```ts
+     * const copyArray = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+     *   const copy = arr.copy();
+     *   copy.pushLast(99n);
+     *   $.return(copy);
+     * });
+     * const compiled = East.compile(copyArray.toIR(), []);
+     * const original = [1n, 2n, 3n];
+     * compiled(original);  // [1n, 2n, 3n, 99n]
+     * // original is unchanged: [1n, 2n, 3n]
+     * ```
+     */
+    copy() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "ArrayCopy",
+            type_parameters: [this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    map(fn) {
+        // We need to infer the output type
+        if (fn instanceof Expr) {
+            // The function was provided as an expression
+            if (!(fn[TypeSymbol] && fn[TypeSymbol].type === "Function")) {
+                throw new Error("Expected a Function expression");
+            }
+            const output_type = fn[TypeSymbol].output;
+            const n_inputs = fn[TypeSymbol].inputs.length;
+            if (n_inputs === 2) {
+                // Two input function (value, index)
+                if (!isSubtype(this.value_type, fn[TypeSymbol].inputs[0])) {
+                    throw new Error(`Expected Function input to be ${printType(this.value_type)}, got ${printType(fn[TypeSymbol].inputs[0])}`);
+                }
+                if (!isTypeEqual(IntegerType, fn[TypeSymbol].inputs[1])) {
+                    throw new Error(`Expected Function second input to be ${printType(IntegerType)}, got ${printType(fn[TypeSymbol].inputs[1])}`);
+                }
+                return this[FactorySymbol]({
+                    ast_type: "Builtin",
+                    type: ArrayType(output_type),
+                    location: get_location(2),
+                    builtin: "ArrayMap",
+                    type_parameters: [this.value_type, output_type],
+                    arguments: [this[AstSymbol], fn[AstSymbol]],
+                });
+            }
+            else {
+                throw new Error(`Expected Function to have 2 inputs, got ${n_inputs} inputs`);
+            }
+        }
+        else {
+            // The function was provided as a lambda
+            // We need to convert it to a FunctionExpr first, but we also need to infer the output type (using undefined)
+            const functionExpr = Expr.function([this.value_type, IntegerType], undefined, fn);
+            return this.map(functionExpr);
+        }
+    }
+    /**
+     * Filters array elements using a predicate function.
+     *
+     * @param predicate - Function taking (element, index) and returning true to keep the element
+     * @returns A new ArrayExpr containing only elements for which the predicate returned true
+     *
+     * @example
+     * ```ts
+     * const filterEven = East.function([ArrayType(IntegerType)], ArrayType(IntegerType), ($, arr) => {
+     *   $.return(arr.filter(($, x, i) => x.modulo(2n).equal(0n)));
+     * });
+     * const compiled = East.compile(filterEven.toIR(), []);
+     * compiled([1n, 2n, 3n, 4n, 5n, 6n]);  // [2n, 4n, 6n]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Filter by index
+     * const filterFirstThree = East.function([ArrayType(StringType)], ArrayType(StringType), ($, arr) => {
+     *   $.return(arr.filter(($, elem, index) => index.lessThan(3n)));
+     * });
+     * const compiled = East.compile(filterFirstThree.toIR(), []);
+     * compiled(["a", "b", "c", "d", "e"]);  // ["a", "b", "c"]
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Filter structs by field
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const filterAdults = East.function([ArrayType(PersonType)], ArrayType(PersonType), ($, people) => {
+     *   $.return(people.filter(($, p, i) => p.age.greaterOrEqual(18n)));
+     * });
+     * const compiled = East.compile(filterAdults.toIR(), []);
+     * compiled([{ name: "Alice", age: 30n }, { name: "Bob", age: 15n }]);  // [{ name: "Alice", age: 30n }]
+     * ```
+     */
+    filter(predicate) {
+        if (!(predicate instanceof Expr)) {
+            predicate = Expr.function([this.value_type, IntegerType], BooleanType, predicate);
+        }
+        // Check if it's actually a FunctionExpr by looking at its type
+        if (!predicate[TypeSymbol] || predicate[TypeSymbol].type !== "Function") {
+            throw new Error("forEach expects a Function expression");
+        }
+        const functionType = predicate[TypeSymbol];
+        if (functionType.inputs.length === 2) {
+            // Two input function (value, index)
+            if (!isSubtype(this.value_type, functionType.inputs[0])) {
+                throw new Error(`Expected Function input to be ${printType(this.value_type)}, got ${printType(functionType.inputs[0])}`);
+            }
+            if (!isTypeEqual(IntegerType, functionType.inputs[1])) {
+                throw new Error(`Expected Function second input to be ${printType(IntegerType)}, got ${printType(functionType.inputs[1])}`);
+            }
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                location: get_location(2),
+                type: this[TypeSymbol],
+                builtin: "ArrayFilter",
+                type_parameters: [this.value_type],
+                arguments: [this[AstSymbol], predicate[AstSymbol]],
+            });
+        }
+        else {
+            throw new Error(`Expected Function to have 2 inputs, got ${functionType.inputs.length} inputs`);
+        }
+    }
+    filterMap(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const returnType = fnAst.type.output;
+        if (returnType.type !== "Variant") {
+            throw new Error(`Expected Function to return an Option type, got ${printType(returnType)}`);
+        }
+        if (!Object.keys(returnType.cases).every(k => k === "none" || k === "some")) {
+            throw new Error(`Expected Function to return an Option type, got ${printType(returnType)}`);
+        }
+        const someType = returnType.cases["some"] ?? NeverType;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: ArrayType(someType),
+            location: get_location(2),
+            builtin: "ArrayFilterMap",
+            type_parameters: [this.value_type, someType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    firstMap(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const returnType = fnAst.type.output;
+        if (returnType.type !== "Variant") {
+            throw new Error(`Expected Function to return an Option type, got ${printType(returnType)}`);
+        }
+        if (!Object.keys(returnType.cases).every(k => k === "none" || k === "some")) {
+            throw new Error(`Expected Function to return an Option type, got ${printType(returnType)}`);
+        }
+        const someType = returnType.cases["some"] ?? NeverType;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: returnType,
+            location: get_location(2),
+            builtin: "ArrayFirstMap",
+            type_parameters: [this.value_type, someType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    findFirst(value, by) {
+        if (by === undefined) {
+            return this.firstMap(($, v, k) => Expr.equal(v, value).ifElse(() => some(k), () => none));
+        }
+        else {
+            const byExpr = (by instanceof Expr ? by : Expr.function([this.value_type, IntegerType], undefined, by));
+            if (byExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'by' parameter");
+            }
+            const byType = byExpr[TypeSymbol];
+            if (byType.inputs.length !== 2) {
+                throw new Error(`Expected 'by' function to have 2 inputs, got ${byType.inputs.length}`);
+            }
+            if (!isSubtype(this.value_type, byType.inputs[0])) {
+                throw new Error(`Expected 'by' function input to be ${printType(this.value_type)}, got ${printType(byType.inputs[0])}`);
+            }
+            return this.firstMap(($, v, k) => Expr.equal(byExpr(v, k), value).ifElse(() => some(k), () => none));
+        }
+    }
+    findAll(value, by) {
+        if (by === undefined) {
+            return this.filterMap(($, v, k) => Expr.equal(v, value).ifElse(() => some(k), () => none));
+        }
+        else {
+            const byExpr = (by instanceof Expr ? by : Expr.function([this.value_type, IntegerType], undefined, by));
+            if (byExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'by' parameter");
+            }
+            const byType = byExpr[TypeSymbol];
+            if (byType.inputs.length !== 2) {
+                throw new Error(`Expected 'by' function to have 2 inputs, got ${byType.inputs.length}`);
+            }
+            if (!isSubtype(this.value_type, byType.inputs[0])) {
+                throw new Error(`Expected 'by' function input to be ${printType(this.value_type)}, got ${printType(byType.inputs[0])}`);
+            }
+            return this.filterMap(($, v, k) => Expr.equal(byExpr(v, k), value).ifElse(() => some(k), () => none));
+        }
+    }
+    /**
+     * Reduces the array to a single value using an accumulator function and initial value.
+     *
+     * @param combineFn - Function taking (accumulator, element, index) and returning the new accumulator value
+     * @param init - Initial value for the reduction (determines output type)
+     * @returns The final accumulated value
+     *
+     * @remarks
+     * The accumulator function is called for each element with the previous result (or initial value for first element),
+     * the current value, and the current index. This operation is safe on empty arrays (returns the initial value).
+     *
+     * @example
+     * ```ts
+     * const sumArray = East.function([ArrayType(IntegerType)], IntegerType, ($, arr) => {
+     *   $.return(arr.reduce(($, acc, val, index) => acc.add(val), 0n));
+     * });
+     * const compiled = East.compile(sumArray.toIR(), []);
+     * compiled([1n, 2n, 3n, 4n]);  // 10n
+     * compiled([]);                // 0n (initial value)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Building a string from array
+     * const joinArray = East.function([ArrayType(StringType)], StringType, ($, arr) => {
+     *   $.return(arr.reduce(($, acc, val, index) =>
+     *     $.if(index.equal(0n), () => val, () => acc.concat(", ").concat(val))
+     *   , ""));
+     * });
+     * const compiled = East.compile(joinArray.toIR(), []);
+     * compiled(["a", "b", "c"]);  // "a, b, c"
+     * ```
+     *
+     * @see {@link mapReduce} for a version that projects each value before reducing (and errors on empty arrays).
+     * @see {@link sum}, {@link mean}, {@link every}, and {@link some} for common reduction operations.
+     */
+    reduce(combineFn, init) {
+        const initAst = valueOrExprToAst(init);
+        const returnType = initAst.type;
+        const combineAst = valueOrExprToAstTyped(combineFn, FunctionType([returnType, this.value_type, IntegerType], returnType, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: returnType,
+            location: get_location(2),
+            builtin: "ArrayFold",
+            type_parameters: [this.value_type, returnType],
+            arguments: [this[AstSymbol], initAst, combineAst],
+        });
+    }
+    mapReduce(mapFn, combineFn) {
+        const mapAst = valueOrExprToAstTyped(mapFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const mapType = mapAst.type.output;
+        const combineAst = valueOrExprToAstTyped(combineFn, FunctionType([mapType, mapType], mapType, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: mapType,
+            location: get_location(2),
+            builtin: "ArrayMapReduce",
+            type_parameters: [this.value_type, mapType],
+            arguments: [this[AstSymbol], mapAst, combineAst],
+        });
+    }
+    // Common reducers are provided, based on reduce
+    /**
+     * Returns true if every element satisfies the predicate, false otherwise.
+     *
+     * @param fn - Optional predicate function (required for non-Boolean arrays)
+     * @returns A BooleanExpr (true for empty arrays)
+     *
+     * @remarks
+     * This method short-circuits on the first false element for efficiency.
+     *
+     * @example
+     * ```ts
+     * const allPositive = East.function([ArrayType(IntegerType)], BooleanType, ($, arr) => {
+     *   $.return(arr.every(($, x, i) => x.greater(0n)));
+     * });
+     * const compiled = East.compile(allPositive.toIR(), []);
+     * compiled([1n, 2n, 3n]);   // true
+     * compiled([1n, -2n, 3n]);  // false
+     * compiled([]);             // true (empty array)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Checking structs
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const allAdults = East.function([ArrayType(PersonType)], BooleanType, ($, people) => {
+     *   $.return(people.every(($, p, i) => p.age.greaterOrEqual(18n)));
+     * });
+     * const compiled = East.compile(allAdults.toIR(), []);
+     * compiled([{ name: "Alice", age: 30n }, { name: "Bob", age: 25n }]);  // true
+     * ```
+     *
+     * @see {@link some} to check if at least one element is true.
+     */
+    every(fn) {
+        if (fn === undefined) {
+            if (!isTypeEqual(this.value_type, BooleanType)) {
+                throw new Error(`Can only perform every on array of booleans, got ${printType(this.value_type)}`);
+            }
+            // Short-circuit on first false value
+            const result = this.firstMap(($, v, _k) => v.not().ifElse(() => some(null), () => none));
+            return Expr.match(result, { some: () => false, none: () => true });
+        }
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, IntegerType], BooleanType, null));
+        // Short-circuit on first false value
+        const result = this.firstMap(($, v, k) => {
+            const result = Expr.fromAst(fnAst)(v, k);
+            return result.not().ifElse(() => some(null), () => none);
+        });
+        return Expr.match(result, { some: () => false, none: () => true });
+    }
+    /**
+     * Returns true if at least one element satisfies the predicate, false otherwise.
+     *
+     * @param fn - Optional predicate function (required for non-Boolean arrays)
+     * @returns A BooleanExpr (false for empty arrays)
+     *
+     * @remarks
+     * This method short-circuits on the first true element for efficiency.
+     *
+     * @example
+     * ```ts
+     * const hasNegative = East.function([ArrayType(IntegerType)], BooleanType, ($, arr) => {
+     *   $.return(arr.some(($, x, i) => x.less(0n)));
+     * });
+     * const compiled = East.compile(hasNegative.toIR(), []);
+     * compiled([1n, 2n, 3n]);    // false
+     * compiled([1n, -2n, 3n]);   // true
+     * compiled([]);              // false (empty array)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Checking structs
+     * const PersonType = StructType({ name: StringType, age: IntegerType });
+     * const hasMinor = East.function([ArrayType(PersonType)], BooleanType, ($, people) => {
+     *   $.return(people.some(($, p, i) => p.age.less(18n)));
+     * });
+     * const compiled = East.compile(hasMinor.toIR(), []);
+     * compiled([{ name: "Alice", age: 30n }, { name: "Bob", age: 15n }]);  // true
+     * ```
+     *
+     * @see {@link every} to check if all elements are true.
+     */
+    some(fn) {
+        if (fn === undefined) {
+            if (!isTypeEqual(this.value_type, BooleanType)) {
+                throw new Error(`Can only perform some on array of booleans, got ${printType(this.value_type)}`);
+            }
+            // Short-circuit on first true value
+            const result = this.firstMap(($, v, _k) => v.ifElse(() => some(null), () => none));
+            return Expr.match(result, { some: () => true, none: () => false });
+        }
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, IntegerType], BooleanType, null));
+        // Short-circuit on first true value
+        const result = this.firstMap(($, v, k) => {
+            const result = Expr.fromAst(fnAst)(v, k);
+            return result.ifElse(() => some(null), () => none);
+        });
+        return Expr.match(result, { some: () => true, none: () => false });
+    }
+    sum(fn) {
+        if (fn === undefined) {
+            if (!(isTypeEqual(this.value_type, IntegerType) || isTypeEqual(this.value_type, FloatType))) {
+                throw new Error(`Can only perform sum on array of numbers (Integer or Float), got ${printType(this.value_type)}`);
+            }
+            const zero = isTypeEqual(this.value_type, IntegerType) ? 0n : 0.0;
+            return this.reduce(($, previous, value) => previous.add(value), zero);
+        }
+        else {
+            const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, IntegerType], undefined, null));
+            const returnType = fnAst.type.output;
+            if (!(isTypeEqual(returnType, IntegerType) || isTypeEqual(returnType, FloatType))) {
+                throw new Error(`Can only perform sum on array of numbers (Integer or Float), got ${printType(returnType)}`);
+            }
+            const zero = isTypeEqual(returnType, IntegerType) ? 0n : 0.0;
+            return this.reduce(($, previous, value, key) => previous.add(Expr.fromAst(fnAst)(value, key)), zero);
+        }
+    }
+    mean(fn) {
+        if (fn === undefined) {
+            if (isTypeEqual(this.value_type, IntegerType)) {
+                return this.reduce(($, previous, value) => previous.add(value.toFloat()), 0.0).divide(this.size().toFloat());
+            }
+            else if (isTypeEqual(this.value_type, FloatType)) {
+                return this.reduce(($, previous, value) => previous.add(value), 0.0).divide(this.size().toFloat());
+            }
+            else {
+                throw new Error(`Can only perform sum on array of numbers (Integer or Float), got ${printType(this.value_type)}`);
+            }
+        }
+        else {
+            const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, IntegerType], undefined, null));
+            const returnType = fnAst.type.output;
+            if (isTypeEqual(returnType, IntegerType)) {
+                return this.reduce(($, previous, value, key) => previous.add(Expr.fromAst(fnAst)(value, key).toFloat()), 0.0).divide(this.size().toFloat());
+            }
+            else if (isTypeEqual(returnType, FloatType)) {
+                return this.reduce(($, previous, value, key) => previous.add(Expr.fromAst(fnAst)(value, key)), 0.0).divide(this.size().toFloat());
+            }
+            else {
+                throw new Error(`Can only perform sum on array of numbers (Integer or Float), got ${printType(returnType)}`);
+            }
+        }
+    }
+    findMaximum(by) {
+        if (by === undefined) {
+            // No projection - compare elements directly
+            if (!(isDataType(this.value_type))) {
+                throw new Error(`Can only perform findMaximum on arrays of data types, got ${printType(this.value_type)}`);
+            }
+            // Check if array is empty first
+            return Expr.equal(this.size(), 0n).ifElse(() => none, () => {
+                const result = this.mapReduce(($, x, k) => ({ index: k, value: x }), ($, a, b) => Expr.greaterEqual(a.value, b.value).ifElse(() => a, () => b));
+                return some(result.index);
+            });
+        }
+        else {
+            // With projection - need to track element, projected value, and index
+            const byExpr = (by instanceof Expr ? by : Expr.function([this.value_type, IntegerType], undefined, by));
+            if (byExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'by' parameter");
+            }
+            const byType = byExpr[TypeSymbol];
+            const projectedType = byType.output;
+            if (!isDataType(projectedType)) {
+                throw new Error(`Can only compare data types, got ${printType(projectedType)}`);
+            }
+            // Check if array is empty first
+            return Expr.equal(this.size(), 0n).ifElse(() => none, () => {
+                // Map to { index, key }, reduce by comparing keys, extract index
+                const result = this.mapReduce(($, x, k) => ({ index: k, key: byExpr(x, k) }), ($, a, b) => Expr.greaterEqual(a.key, b.key).ifElse(() => a, () => b));
+                return some(result.index);
+            });
+        }
+    }
+    findMinimum(by) {
+        if (by === undefined) {
+            // No projection - compare elements directly
+            if (!(isDataType(this.value_type))) {
+                throw new Error(`Can only perform findMinimum on arrays of data types, got ${printType(this.value_type)}`);
+            }
+            // Check if array is empty first
+            return Expr.equal(this.size(), 0n).ifElse(() => none, () => {
+                const result = this.mapReduce(($, x, k) => ({ index: k, value: x }), ($, a, b) => Expr.lessEqual(a.value, b.value).ifElse(() => a, () => b));
+                return some(result.index);
+            });
+        }
+        else {
+            // With projection - need to track element, projected value, and index
+            const byExpr = (by instanceof Expr ? by : Expr.function([this.value_type, IntegerType], undefined, by));
+            if (byExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'by' parameter");
+            }
+            const byType = byExpr[TypeSymbol];
+            const projectedType = byType.output;
+            if (!isDataType(projectedType)) {
+                throw new Error(`Can only compare data types, got ${printType(projectedType)}`);
+            }
+            // Check if array is empty first
+            return Expr.equal(this.size(), 0n).ifElse(() => none, () => {
+                // Map to { index, key }, reduce by comparing keys, extract index
+                const result = this.mapReduce(($, x, k) => ({ index: k, key: byExpr(x, k) }), ($, a, b) => Expr.lessEqual(a.key, b.key).ifElse(() => a, () => b));
+                return some(result.index);
+            });
+        }
+    }
+    maximum(by) {
+        if (by === undefined) {
+            // No projection - compare elements directly
+            // Use mapReduce with lambda functions directly
+            return this.mapReduce(($, x) => x, Expr.function([this.value_type, this.value_type], this.value_type, ($, a, b) => Expr.max(a, b)));
+        }
+        else {
+            // With projection - need to track both element and projected value
+            const byExpr = (by instanceof Expr ? by : Expr.function([this.value_type, IntegerType], undefined, by));
+            if (byExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'by' parameter");
+            }
+            const byType = byExpr[TypeSymbol];
+            const projectedType = byType.output;
+            if (!isDataType(projectedType)) {
+                throw new Error(`Can only compare data types, got ${printType(projectedType)}`);
+            }
+            // Map to { element, key }, reduce by comparing keys, extract element
+            // Use greaterEqual to keep the first element when keys are equal
+            const result = this.mapReduce(($, x, k) => ({ element: x, key: byExpr(x, k) }), ($, a, b) => Expr.greaterEqual(a.key, b.key).ifElse(() => a, () => b));
+            return result.element;
+        }
+    }
+    minimum(by) {
+        if (by === undefined) {
+            // No projection - compare elements directly
+            if (!(isDataType(this.value_type))) {
+                throw new Error(`Can only perform minimum on arrays of data types, got ${printType(this.value_type)}`);
+            }
+            // Use mapReduce with lambda functions directly
+            return this.mapReduce(($, x) => x, Expr.function([this.value_type, this.value_type], this.value_type, ($, a, b) => Expr.min(a, b)));
+        }
+        else {
+            // With projection - need to track both element and projected value
+            const byExpr = (by instanceof Expr ? by : Expr.function([this.value_type, IntegerType], undefined, by));
+            if (byExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'by' parameter");
+            }
+            const byType = byExpr[TypeSymbol];
+            const projectedType = byType.output;
+            if (!isDataType(projectedType)) {
+                throw new Error(`Can only compare data types, got ${printType(projectedType)}`);
+            }
+            // Map to { element, key }, reduce by comparing keys, extract element
+            // Use lessEqual to keep the first element when keys are equal
+            const result = this.mapReduce(($, x, k) => ({ element: x, key: byExpr(x, k) }), ($, a, b) => Expr.lessEqual(a.key, b.key).ifElse(() => a, () => b));
+            return result.element;
+        }
+    }
+    /**
+     * Joins string array elements with a delimiter.
+     *
+     * @param string - The delimiter string to insert between elements
+     * @returns A StringExpr with all elements joined
+     *
+     * @remarks
+     * This method only works on arrays of strings.
+     *
+     * @example
+     * ```ts
+     * const joinStrings = East.function([ArrayType(StringType), StringType], StringType, ($, arr, delimiter) => {
+     *   $.return(arr.stringJoin(delimiter));
+     * });
+     * const compiled = East.compile(joinStrings.toIR(), []);
+     * compiled(["a", "b", "c"], ", ");  // "a, b, c"
+     * compiled(["hello", "world"], " "); // "hello world"
+     * compiled([], ", ");                // ""
+     * ```
+     */
+    stringJoin(string) {
+        if (!isTypeEqual(this.value_type, StringType)) {
+            throw new Error(`Can only perform stringJoin on array of strings - try using map to convert the values to strings first`);
+        }
+        const stringAst = valueOrExprToAstTyped(string, StringType);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: StringType,
+            location: get_location(2),
+            builtin: "ArrayStringJoin",
+            type_parameters: [],
+            arguments: [this[AstSymbol], stringAst],
+        });
+    }
+    toSet(keyFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyType = keyFnAst.type.output;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: SetType(keyType),
+            location: get_location(2),
+            builtin: "ArrayToSet",
+            type_parameters: [this.value_type, keyType],
+            arguments: [this[AstSymbol], keyFnAst],
+        });
+    }
+    toDict(keyFn, valueFn, onConflictFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, x, i) => i), FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyType = keyFnAst.type.output;
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueType = valueFnAst.type.output;
+        let onConflictAst;
+        if (onConflictFn === undefined) {
+            const location = get_location(2);
+            const onConflictFunction = Expr.function([valueType, valueType, keyType], valueType, ($, existing, value, key) => $.error(Expr.str `Cannot insert duplicate key ${key} into dict`, location));
+            onConflictAst = Expr.ast(onConflictFunction);
+        }
+        else {
+            onConflictAst = valueOrExprToAstTyped(onConflictFn, FunctionType([valueType, valueType, keyType], valueType, null));
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: DictType(keyType, valueType),
+            location: get_location(2),
+            builtin: "ArrayToDict",
+            type_parameters: [this.value_type, keyType, valueType],
+            arguments: [this[AstSymbol], keyFnAst, valueFnAst, onConflictAst],
+        });
+    }
+    flatMap(fn) {
+        const fnAst = valueOrExprToAstTyped(fn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const returnType = fnAst.type.output;
+        if (returnType.type !== "Array") {
+            throw new Error(`Expected Function to return an Array type, got ${printType(returnType)}`);
+        }
+        const elementType = returnType.value;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: ArrayType(elementType),
+            location: get_location(2),
+            builtin: "ArrayFlattenToArray",
+            type_parameters: [this.value_type, elementType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    flattenToSet(fn) {
+        const fnAst = valueOrExprToAstTyped(fn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const returnType = fnAst.type.output;
+        if (returnType.type !== "Set") {
+            throw new Error(`Expected Function to return a Set type, got ${printType(returnType)}`);
+        }
+        const elementType = returnType.key;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: SetType(elementType),
+            location: get_location(2),
+            builtin: "ArrayFlattenToSet",
+            type_parameters: [this.value_type, elementType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    flattenToDict(fn, onConflictFn) {
+        const fnAst = valueOrExprToAstTyped(fn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const returnType = fnAst.type.output;
+        if (returnType.type !== "Dict") {
+            throw new Error(`Expected Function to return a Dict type, got ${printType(returnType)}`);
+        }
+        const keyType = returnType.key;
+        const valueType = returnType.value;
+        let onConflictAst;
+        if (onConflictFn === undefined) {
+            const location = get_location(2);
+            const onConflictFunction = Expr.function([valueType, valueType, keyType], valueType, ($, existing, value, key) => $.error(Expr.str `Cannot insert duplicate key ${key} into dict`, location));
+            onConflictAst = Expr.ast(onConflictFunction);
+        }
+        else {
+            onConflictAst = valueOrExprToAstTyped(onConflictFn, FunctionType([valueType, valueType, keyType], valueType, null));
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: DictType(keyType, valueType),
+            location: get_location(2),
+            builtin: "ArrayFlattenToDict",
+            type_parameters: [this.value_type, keyType, valueType],
+            arguments: [this[AstSymbol], fnAst, onConflictAst],
+        });
+    }
+    groupReduce(keyFn, initFn, reduceFn) {
+        // Note - initFn has to be before reduceFn, otherwise the TypeScript type inference doesn't work properly
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyType = keyFnAst.type.output;
+        const initFnAst = valueOrExprToAstTyped(initFn, FunctionType([keyType], undefined, null));
+        const initType = initFnAst.type.output;
+        const reduceFnAst = valueOrExprToAstTyped(reduceFn, FunctionType([initType, this.value_type, IntegerType], initType, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: DictType(keyType, initType),
+            location: get_location(2),
+            builtin: "ArrayGroupFold",
+            type_parameters: [this.value_type, keyType, initType],
+            arguments: [this[AstSymbol], keyFnAst, initFnAst, reduceFnAst],
+        });
+    }
+    groupSize(keyFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$) => 1n), ((_$, a, b) => a.add(b)));
+    }
+    groupEvery(keyFn, predFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const predFnAst = valueOrExprToAstTyped(predFn, FunctionType([this.value_type, IntegerType], BooleanType, null));
+        return this.groupReduce(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), (() => true), ((_$, acc, elem, idx) => {
+            const pred = Expr.fromAst(predFnAst)(elem, idx);
+            return acc.and(() => pred);
+        }));
+    }
+    groupSome(keyFn, predFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const predFnAst = valueOrExprToAstTyped(predFn, FunctionType([this.value_type, IntegerType], BooleanType, null));
+        return this.groupReduce(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), (() => false), ((_$, acc, elem, idx) => {
+            const pred = Expr.fromAst(predFnAst)(elem, idx);
+            return acc.or(() => pred);
+        }));
+    }
+    groupFindAll(keyFn, value, projFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        if (projFn === undefined) {
+            // Without projection: find where element == value
+            return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from([], ArrayType(IntegerType))), (($, acc, elem, idx) => {
+                $.if(Expr.equal(elem, value), ($) => $(acc.pushLast(idx)));
+                return acc;
+            }));
+        }
+        else {
+            // With projection: find where projFn(element) == value
+            const projFnExpr = (projFn instanceof Expr ? projFn : Expr.function([this.value_type, IntegerType], undefined, projFn));
+            if (projFnExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'projFn' parameter");
+            }
+            return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from([], ArrayType(IntegerType))), (($, acc, elem, idx) => {
+                $.if(Expr.equal(projFnExpr(elem, idx), value), ($) => $(acc.pushLast(idx)));
+                return acc;
+            }));
+        }
+    }
+    groupFindFirst(keyFn, value, projFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        if (projFn === undefined) {
+            // Without projection: find where element == value
+            return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from(none, OptionType(IntegerType))), ((_$, acc, elem, idx) => {
+                const isSome = acc.hasTag("some");
+                return isSome.ifElse(() => acc, () => Expr.equal(elem, value).ifElse(() => some(idx), () => Expr.from(none, OptionType(IntegerType))));
+            }));
+        }
+        else {
+            // With projection: find where projFn(element) == value
+            const projFnExpr = (projFn instanceof Expr ? projFn : Expr.function([this.value_type, IntegerType], undefined, projFn));
+            if (projFnExpr[TypeSymbol].type !== "Function") {
+                throw new Error("Expected a Function expression for 'projFn' parameter");
+            }
+            return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from(none, OptionType(IntegerType))), ((_$, acc, elem, idx) => {
+                const isSome = acc.hasTag("some");
+                return isSome.ifElse(() => acc, () => Expr.equal(projFnExpr(elem, idx), value).ifElse(() => some(idx), () => Expr.from(none, OptionType(IntegerType))));
+            }));
+        }
+    }
+    groupFindMinimum(keyFn, byFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const byFnAst = valueOrExprToAstTyped(byFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$, elem, idx) => ({ by: Expr.fromAst(byFnAst)(elem, idx), index: idx })), ((_$, a, b) => Expr.lessEqual(a.by, b.by).ifElse(() => a, () => b))).map(((_$, v) => v.index));
+    }
+    groupFindMaximum(keyFn, byFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const byFnAst = valueOrExprToAstTyped(byFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$, elem, idx) => ({ by: Expr.fromAst(byFnAst)(elem, idx), index: idx })), ((_$, a, b) => Expr.greaterEqual(a.by, b.by).ifElse(() => a, () => b))).map(((_$, v) => v.index));
+    }
+    groupSum(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueType = valueFnAst.type.output;
+        const isInteger = isTypeEqual(valueType, IntegerType);
+        const isFloat = isTypeEqual(valueType, FloatType);
+        if (!isInteger && !isFloat) {
+            throw new Error(`Can only perform groupSum on Integer or Float values, got ${printType(valueType)}`);
+        }
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$, elem, idx) => Expr.fromAst(valueFnAst)(elem, idx)), ((_$, a, b) => a.add(b)));
+    }
+    groupMean(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueType = valueFnAst.type.output;
+        const isInteger = isTypeEqual(valueType, IntegerType);
+        const isFloat = isTypeEqual(valueType, FloatType);
+        if (!isInteger && !isFloat) {
+            throw new Error(`Can only perform groupMean on Integer or Float values, got ${printType(valueType)}`);
+        }
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$, elem, idx) => {
+            const val = Expr.fromAst(valueFnAst)(elem, idx);
+            return { sum: isInteger ? val.toFloat() : val, count: 1n };
+        }), ((_$, a, b) => ({ sum: a.sum.add(b.sum), count: a.count.add(b.count) }))).map(((_$, v) => v.sum.divide(v.count.toFloat())));
+    }
+    groupToArrays(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const valueType = valueFnAst.type.output;
+        return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from([], ArrayType(valueType))), (($, acc, elem, idx) => {
+            const val = valueFnExpr(elem, idx);
+            $(acc.pushLast(val));
+            return acc;
+        }));
+    }
+    groupToSets(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const valueType = valueFnAst.type.output;
+        return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from(new Set(), SetType(valueType))), (($, acc, elem, idx) => {
+            const val = valueFnExpr(elem, idx);
+            $(acc.tryInsert(val));
+            return acc;
+        }));
+    }
+    groupMinimum(keyFn, byFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const byFnAst = valueOrExprToAstTyped(byFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$, elem, idx) => ({ by: Expr.fromAst(byFnAst)(elem, idx), elem })), ((_$, a, b) => Expr.lessEqual(a.by, b.by).ifElse(() => a, () => b))).map(((_$, v) => v.elem));
+    }
+    groupMaximum(keyFn, byFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const byFnAst = valueOrExprToAstTyped(byFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        return this.toDict(((_$, elem, idx) => Expr.fromAst(keyFnAst)(elem, idx)), ((_$, elem, idx) => ({ by: Expr.fromAst(byFnAst)(elem, idx), elem })), ((_$, a, b) => Expr.greaterEqual(a.by, b.by).ifElse(() => a, () => b))).map(((_$, v) => v.elem));
+    }
+    groupToDicts(keyFn, keyFn2, valueFn, combineFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyFn2Ast = valueOrExprToAstTyped(keyFn2, FunctionType([this.value_type, IntegerType], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.value_type, IntegerType], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const keyFn2Expr = Expr.fromAst(keyFn2Ast);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const key2Type = keyFn2Ast.type.output;
+        const valueType = valueFnAst.type.output;
+        if (combineFn !== undefined) {
+            // With conflict resolution - use tryGet + match to check existence, then insert or combine
+            const combineFnAst = valueOrExprToAstTyped(combineFn, FunctionType([valueType, valueType], valueType, null));
+            const combineFnExpr = Expr.fromAst(combineFnAst);
+            return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from(new Map(), DictType(key2Type, valueType))), (($, dict, elem, idx) => {
+                const innerKey = keyFn2Expr(elem, idx);
+                const val = valueFnExpr(elem, idx);
+                $.match(dict.tryGet(innerKey), {
+                    some: ($, existing) => {
+                        const combined = combineFnExpr(existing, val);
+                        $(dict.update(innerKey, combined));
+                    },
+                    none: ($) => {
+                        $(dict.insert(innerKey, val));
+                    }
+                });
+                return dict;
+            }));
+        }
+        else {
+            // Without conflict resolution - use insert (errors on duplicate)
+            return this.groupReduce(((_$, elem, idx) => keyFnExpr(elem, idx)), ((_$, _key) => Expr.from(new Map(), DictType(key2Type, valueType))), (($, dict, elem, idx) => {
+                const innerKey = keyFn2Expr(elem, idx);
+                const val = valueFnExpr(elem, idx);
+                $(dict.insert(innerKey, val));
+                return dict;
+            }));
+        }
+    }
+}
+//# sourceMappingURL=array.js.map