@elaraai/east 0.0.1-beta.0

package/dist/src/expr/set.js

@@ -0,0 +1,1137 @@
+import { get_location } from "../location.js";
+import { SetType, BooleanType, FunctionType, IntegerType, NullType, NeverType, DictType, printType, FloatType, isTypeEqual, ArrayType, VariantType } from "../types.js";
+import { valueOrExprToAst, valueOrExprToAstTyped } from "./ast.js";
+import { AstSymbol, Expr, TypeSymbol } from "./expr.js";
+import { none, some } from "../containers/variant.js";
+/**
+ * Expression representing set (sorted unique collection) values and operations.
+ *
+ * SetExpr provides methods for working with sorted sets including membership testing, insertion,
+ * deletion, iteration, mapping, filtering, set operations (union, intersection, difference), and
+ * aggregation operations. Sets maintain their elements sorted by key using East's total ordering
+ * and guarantee uniqueness.
+ *
+ * @example
+ * ```ts
+ * // Creating and manipulating sets
+ * const buildSet = East.function([ArrayType(StringType)], SetType(StringType), ($, items) => {
+ *   const uniqueItems = Expr.from(new Set(), SetType(StringType));
+ *   $(items.forEach(($, item) => {
+ *     $(uniqueItems.tryInsert(item));
+ *   }));
+ *   $.return(uniqueItems);
+ * });
+ * const compiled = East.compile(buildSet.toIR(), []);
+ * compiled(["apple", "banana", "apple", "cherry"]);  // Set(["apple", "banana", "cherry"])
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Set operations
+ * const unionSets = East.function([SetType(IntegerType), SetType(IntegerType)], SetType(IntegerType), ($, set1, set2) => {
+ *   $.return(set1.union(set2));
+ * });
+ * const compiled = East.compile(unionSets.toIR(), []);
+ * compiled(new Set([1n, 2n, 3n]), new Set([3n, 4n, 5n]));  // Set([1n, 2n, 3n, 4n, 5n])
+ * ```
+ */
+export class SetExpr extends Expr {
+    key_type;
+    constructor(key_type, ast, createExpr) {
+        super(ast.type, ast, createExpr);
+        this.key_type = key_type;
+    }
+    /**
+     * Returns the number of elements in the set.
+     *
+     * @returns An IntegerExpr representing the count of elements
+     *
+     * @example
+     * ```ts
+     * const getSize = East.function([SetType(StringType)], IntegerType, ($, set) => {
+     *   $.return(set.size());
+     * });
+     * const compiled = East.compile(getSize.toIR(), []);
+     * compiled(new Set(["a", "b", "c"]));  // 3n
+     * compiled(new Set());  // 0n
+     * ```
+     */
+    size() {
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "SetSize",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Checks if an element exists in the set.
+     *
+     * @param key - The element to search for
+     * @returns A BooleanExpr that is true if the element exists, false otherwise
+     *
+     * @example
+     * ```ts
+     * const hasElement = East.function([SetType(StringType), StringType], BooleanType, ($, set, element) => {
+     *   $.return(set.has(element));
+     * });
+     * const compiled = East.compile(hasElement.toIR(), []);
+     * const set = new Set(["a", "b", "c"]);
+     * compiled(set, "b");  // true
+     * compiled(set, "d");  // false
+     * ```
+     */
+    has(key) {
+        const valueAst = valueOrExprToAstTyped(key, this.key_type);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "SetHas",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], valueAst],
+        });
+    }
+    /**
+     * Inserts a new element into the set.
+     *
+     * @param key - The element to insert
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if the element already exists in the set
+     *
+     * @see {@link tryInsert} for a version that doesn't error on duplicates
+     *
+     * @example
+     * ```ts
+     * const insertElement = East.function([SetType(StringType), StringType], NullType, ($, set, element) => {
+     *   $(set.insert(element));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(insertElement.toIR(), []);
+     * const set = new Set(["a", "b"]);
+     * compiled(set, "c");  // set now has Set(["a", "b", "c"])
+     * // compiled(set, "a") would throw error (duplicate element)
+     * ```
+     */
+    insert(key) {
+        const location = get_location(2);
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: NullType,
+            location,
+            builtin: "SetInsert",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Tries to insert an element into the set, returning whether it was inserted.
+     *
+     * @param key - The element to insert
+     * @returns A BooleanExpr that is true if the element was inserted, false if it already existed
+     *
+     * @see {@link insert} for a version that errors on duplicates
+     *
+     * @example
+     * ```ts
+     * const tryInsertElement = East.function([SetType(StringType), StringType], BooleanType, ($, set, element) => {
+     *   $.return(set.tryInsert(element));
+     * });
+     * const compiled = East.compile(tryInsertElement.toIR(), []);
+     * const set = new Set(["a", "b"]);
+     * compiled(set, "c");  // true (set now has Set(["a", "b", "c"]))
+     * compiled(set, "a");  // false (element already exists, set unchanged)
+     * ```
+     */
+    tryInsert(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "SetTryInsert",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Deletes an element from the set.
+     *
+     * @param key - The element to delete
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if the element does not exist
+     *
+     * @see {@link tryDelete} for a version that doesn't error on missing elements
+     * @see {@link clear} to remove all elements
+     *
+     * @example
+     * ```ts
+     * const deleteElement = East.function([SetType(StringType), StringType], NullType, ($, set, element) => {
+     *   $(set.delete(element));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(deleteElement.toIR(), []);
+     * const set = new Set(["a", "b", "c"]);
+     * compiled(set, "b");  // set now has Set(["a", "c"])
+     * // compiled(set, "d") would throw error (element not found)
+     * ```
+     */
+    delete(key) {
+        const location = get_location(2);
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: NullType,
+            location,
+            builtin: "SetDelete",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Tries to delete an element from the set, returning whether it was deleted.
+     *
+     * @param key - The element to delete
+     * @returns A BooleanExpr that is true if the element was deleted, false if it didn't exist
+     *
+     * @see {@link delete} for a version that errors on missing elements
+     *
+     * @example
+     * ```ts
+     * const tryDeleteElement = East.function([SetType(StringType), StringType], BooleanType, ($, set, element) => {
+     *   $.return(set.tryDelete(element));
+     * });
+     * const compiled = East.compile(tryDeleteElement.toIR(), []);
+     * const set = new Set(["a", "b", "c"]);
+     * compiled(set, "b");  // true (set now has Set(["a", "c"]))
+     * compiled(set, "d");  // false (element not found, set unchanged)
+     * ```
+     */
+    tryDelete(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "SetTryDelete",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Removes all elements from the set.
+     *
+     * @returns A NullExpr
+     *
+     * @see {@link delete} or {@link tryDelete} to remove individual elements
+     *
+     * @example
+     * ```ts
+     * const clearSet = East.function([SetType(StringType)], NullType, ($, set) => {
+     *   $(set.clear());
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(clearSet.toIR(), []);
+     * const set = new Set(["a", "b", "c"]);
+     * compiled(set);  // set is now Set([])
+     * ```
+     */
+    clear() {
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "SetClear",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Unions another set into this one in place.
+     *
+     * @param other - The set whose elements to add to this set
+     * @returns A NullExpr
+     *
+     * @see {@link union} for a version that returns a new set
+     *
+     * @example
+     * ```ts
+     * const unionInPlace = East.function([SetType(IntegerType), SetType(IntegerType)], NullType, ($, set1, set2) => {
+     *   $(set1.unionInPlace(set2));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(unionInPlace.toIR(), []);
+     * const set1 = new Set([1n, 2n, 3n]);
+     * const set2 = new Set([3n, 4n, 5n]);
+     * compiled(set1, set2);  // set1 now has Set([1n, 2n, 3n, 4n, 5n])
+     * ```
+     */
+    unionInPlace(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "SetUnionInPlace",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Returns the union of two sets (all elements from both sets).
+     *
+     * @param other - The set to union with this set
+     * @returns A new SetExpr containing all elements from both sets
+     *
+     * @see {@link unionInPlace} to modify this set in place
+     *
+     * @example
+     * ```ts
+     * const unionSets = East.function([SetType(IntegerType), SetType(IntegerType)], SetType(IntegerType), ($, set1, set2) => {
+     *   $.return(set1.union(set2));
+     * });
+     * const compiled = East.compile(unionSets.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]), new Set([3n, 4n, 5n]));  // Set([1n, 2n, 3n, 4n, 5n])
+     * ```
+     */
+    union(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "SetUnion",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Returns the intersection of two sets (elements common to both).
+     *
+     * @param other - The set to intersect with this set
+     * @returns A new SetExpr containing only elements present in both sets
+     *
+     * @example
+     * ```ts
+     * const intersectSets = East.function([SetType(IntegerType), SetType(IntegerType)], SetType(IntegerType), ($, set1, set2) => {
+     *   $.return(set1.intersection(set2));
+     * });
+     * const compiled = East.compile(intersectSets.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]), new Set([2n, 3n, 4n]));  // Set([2n, 3n])
+     * ```
+     */
+    intersection(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "SetIntersect",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Returns the difference between two sets (elements in this set but not in the other).
+     *
+     * @param other - The set to subtract from this set
+     * @returns A new SetExpr containing elements in this set but not in the other
+     *
+     * @example
+     * ```ts
+     * const diffSets = East.function([SetType(IntegerType), SetType(IntegerType)], SetType(IntegerType), ($, set1, set2) => {
+     *   $.return(set1.difference(set2));
+     * });
+     * const compiled = East.compile(diffSets.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]), new Set([2n, 3n, 4n]));  // Set([1n])
+     * ```
+     */
+    difference(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "SetDiff",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Returns the symmetric difference between two sets (elements in either set but not in both).
+     *
+     * @param other - The set to compute symmetric difference with
+     * @returns A new SetExpr containing elements in either set but not in both
+     *
+     * @example
+     * ```ts
+     * const symDiffSets = East.function([SetType(IntegerType), SetType(IntegerType)], SetType(IntegerType), ($, set1, set2) => {
+     *   $.return(set1.symmetricDifference(set2));
+     * });
+     * const compiled = East.compile(symDiffSets.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]), new Set([2n, 3n, 4n]));  // Set([1n, 4n])
+     * ```
+     */
+    symmetricDifference(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "SetSymDiff",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Checks if this set is a subset of another set (all elements in this set are in the other).
+     *
+     * @param other - The set to check against
+     * @returns A BooleanExpr that is true if this set is a subset of the other
+     *
+     * @example
+     * ```ts
+     * const checkSubset = East.function([SetType(IntegerType), SetType(IntegerType)], BooleanType, ($, set1, set2) => {
+     *   $.return(set1.isSubsetOf(set2));
+     * });
+     * const compiled = East.compile(checkSubset.toIR(), []);
+     * compiled(new Set([1n, 2n]), new Set([1n, 2n, 3n]));  // true
+     * compiled(new Set([1n, 4n]), new Set([1n, 2n, 3n]));  // false
+     * ```
+     */
+    isSubsetOf(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "SetIsSubset",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Checks if this set is a superset of another set (all elements in the other set are in this set).
+     *
+     * @param other - The set to check against
+     * @returns A BooleanExpr that is true if this set is a superset of the other
+     *
+     * @example
+     * ```ts
+     * const checkSuperset = East.function([SetType(IntegerType), SetType(IntegerType)], BooleanType, ($, set1, set2) => {
+     *   $.return(set1.isSupersetOf(set2));
+     * });
+     * const compiled = East.compile(checkSuperset.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]), new Set([1n, 2n]));  // true
+     * compiled(new Set([1n, 2n]), new Set([1n, 2n, 3n]));  // false
+     * ```
+     */
+    isSupersetOf(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "SetIsSubset",
+            type_parameters: [this.key_type],
+            arguments: [otherAst, this[AstSymbol]], // Note: arguments swapped for superset
+        });
+    }
+    /**
+     * Checks if this set is disjoint from another set (no common elements).
+     *
+     * @param other - The set to check against
+     * @returns A BooleanExpr that is true if the sets have no elements in common
+     *
+     * @example
+     * ```ts
+     * const checkDisjoint = East.function([SetType(IntegerType), SetType(IntegerType)], BooleanType, ($, set1, set2) => {
+     *   $.return(set1.isDisjointFrom(set2));
+     * });
+     * const compiled = East.compile(checkDisjoint.toIR(), []);
+     * compiled(new Set([1n, 2n]), new Set([3n, 4n]));  // true
+     * compiled(new Set([1n, 2n]), new Set([2n, 3n]));  // false
+     * ```
+     */
+    isDisjointFrom(other) {
+        const otherAst = valueOrExprToAstTyped(other, this[TypeSymbol]);
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "SetIsDisjoint",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], otherAst],
+        });
+    }
+    /**
+     * Creates a shallow copy of the set.
+     *
+     * @returns A new SetExpr containing the same elements
+     *
+     * @example
+     * ```ts
+     * const copySet = East.function([SetType(StringType)], SetType(StringType), ($, set) => {
+     *   $.return(set.copy());
+     * });
+     * const compiled = East.compile(copySet.toIR(), []);
+     * const set = new Set(["a", "b", "c"]);
+     * const copy = compiled(set);  // Set(["a", "b", "c"])
+     * // Modifying copy doesn't affect set
+     * ```
+     */
+    copy() {
+        // Note that keys are immutable so shallow and deep copy are the same
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "SetCopy",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Filters the set using a predicate function.
+     *
+     * @param pred - Function that returns true to keep an element, false to discard it
+     * @returns A new SetExpr containing only elements for which the predicate returned true
+     *
+     * @example
+     * ```ts
+     * const filterEven = East.function([SetType(IntegerType)], SetType(IntegerType), ($, set) => {
+     *   $.return(set.filter(($, x) => x.modulo(2n).equal(0n)));
+     * });
+     * const compiled = East.compile(filterEven.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n, 4n, 5n, 6n]));  // Set([2n, 4n, 6n])
+     * ```
+     */
+    filter(pred) {
+        const predExpr = Expr.from(pred, FunctionType([this.key_type], BooleanType, null));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "SetFilter",
+            type_parameters: [this.key_type],
+            arguments: [this[AstSymbol], Expr.ast(predExpr)],
+        });
+    }
+    filterMap(fn) {
+        let fnExpr;
+        if (typeof fn === "function") {
+            fnExpr = Expr.function([this.key_type], undefined, fn);
+        }
+        else {
+            fnExpr = fn;
+        }
+        const fnType = fnExpr[TypeSymbol];
+        const returnType = fnType.output;
+        // Extract V2 from the option type
+        if (returnType.type !== "Variant" || !("some" in returnType.cases)) {
+            throw new Error(`filterMap function must return an option type (variant with 'none' and 'some'), got ${printType(returnType)}`);
+        }
+        const valueType = returnType.cases.some;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(this.key_type, valueType),
+            location: get_location(2),
+            builtin: "SetFilterMap",
+            type_parameters: [this.key_type, valueType],
+            arguments: [this[AstSymbol], Expr.ast(fnExpr)],
+        });
+    }
+    firstMap(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], 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 Expr.fromAst({
+            ast_type: "Builtin",
+            type: returnType,
+            location: get_location(2),
+            builtin: "SetFirstMap",
+            type_parameters: [this.key_type, someType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    /**
+     * Iterates over each element in the set, applying a function to each.
+     *
+     * @param fn - Function to apply to each element
+     * @returns A NullExpr
+     *
+     * @example
+     * ```ts
+     * const printElements = East.function([SetType(StringType)], NullType, ($, set) => {
+     *   $(set.forEach(($, element) => {
+     *     // In a real platform, you could use a platform function to log
+     *   }));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(printElements.toIR(), []);
+     * compiled(new Set(["a", "b", "c"]));  // Iterates over all elements
+     * ```
+     */
+    forEach(fn) {
+        const fnExpr = Expr.function([this.key_type], undefined, fn);
+        const fnType = fnExpr[TypeSymbol];
+        const returnType = fnType.output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "SetForEach",
+            type_parameters: [this.key_type, returnType],
+            arguments: [this[AstSymbol], Expr.ast(fnExpr)],
+        });
+    }
+    map(fn) {
+        let fnExpr;
+        if (typeof fn === "function") {
+            fnExpr = Expr.function([this.key_type], undefined, fn);
+        }
+        else {
+            fnExpr = fn;
+        }
+        const fnType = fnExpr[TypeSymbol];
+        const returnType = fnType.output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(this.key_type, returnType),
+            location: get_location(2),
+            builtin: "SetMap",
+            type_parameters: [this.key_type, returnType],
+            arguments: [this[AstSymbol], Expr.ast(fnExpr)],
+        });
+    }
+    mapReduce(mapFn, combineFn) {
+        const mapAst = valueOrExprToAstTyped(mapFn, FunctionType([this.key_type], undefined, null));
+        const mapType = mapAst.type.output;
+        const combineAst = valueOrExprToAstTyped(combineFn, FunctionType([mapType, mapType], mapType, null));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: mapType,
+            location: get_location(2),
+            builtin: "SetMapReduce",
+            type_parameters: [this.key_type, mapType],
+            arguments: [this[AstSymbol], mapAst, combineAst],
+        });
+    }
+    /**
+     * Reduces the set to a single value using an accumulator function.
+     *
+     * @param fn - Function accepting (accumulator, element) and returning the new accumulator value
+     * @param init - Initial value for the accumulator
+     * @returns The final accumulated value
+     *
+     * @see {@link mapReduce} for a version that projects elements before combining
+     *
+     * @example
+     * ```ts
+     * const sumSet = East.function([SetType(IntegerType)], IntegerType, ($, set) => {
+     *   $.return(set.reduce(($, acc, element) => acc.add(element), 0n));
+     * });
+     * const compiled = East.compile(sumSet.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n, 4n]));  // 10n
+     * ```
+     */
+    reduce(fn, init) {
+        const initAst = valueOrExprToAst(init);
+        const returnType = initAst.type;
+        const fnExpr = Expr.from(fn, FunctionType([returnType, this.key_type], returnType, null));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: returnType,
+            location: get_location(2),
+            builtin: "SetReduce",
+            type_parameters: [this.key_type, returnType],
+            arguments: [this[AstSymbol], Expr.ast(fnExpr), initAst],
+        });
+    }
+    toArray(fn) {
+        let fnExpr;
+        if (fn === undefined) {
+            // Identity function
+            fnExpr = Expr.function([this.key_type], this.key_type, ($, key) => key);
+        }
+        else if (typeof fn === "function") {
+            fnExpr = Expr.function([this.key_type], undefined, fn);
+        }
+        else {
+            fnExpr = fn;
+        }
+        const fnType = fnExpr[TypeSymbol];
+        const returnType = fnType.output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: ArrayType(returnType),
+            location: get_location(2),
+            builtin: "SetToArray",
+            type_parameters: [this.key_type, returnType],
+            arguments: [this[AstSymbol], Expr.ast(fnExpr)],
+        });
+    }
+    toSet(keyFn) {
+        let keyFnAst;
+        if (keyFn !== undefined) {
+            let fnExpr;
+            if (typeof keyFn === "function") {
+                fnExpr = Expr.function([this.key_type], undefined, keyFn);
+            }
+            else {
+                fnExpr = keyFn;
+            }
+            keyFnAst = Expr.ast(fnExpr);
+        }
+        else {
+            // Identity function
+            const identityFunction = Expr.function([this.key_type], this.key_type, ($, key) => key);
+            keyFnAst = Expr.ast(identityFunction);
+        }
+        const keyType = keyFnAst.type.output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: SetType(keyType),
+            location: get_location(2),
+            builtin: "SetToSet",
+            type_parameters: [this.key_type, this.key_type],
+            arguments: [this[AstSymbol], keyFnAst],
+        });
+    }
+    toDict(keyFn, valueFn, onConflictFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, x, i) => i), FunctionType([this.key_type], undefined, null));
+        const keyType = keyFnAst.type.output;
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.key_type], 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 Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(keyType, valueType),
+            location: get_location(2),
+            builtin: "SetToDict",
+            type_parameters: [this.key_type, keyType, valueType],
+            arguments: [this[AstSymbol], keyFnAst, valueFnAst, onConflictAst],
+        });
+    }
+    flattenToArray(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], 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 Expr.fromAst({
+            ast_type: "Builtin",
+            type: ArrayType(elementType),
+            location: get_location(2),
+            builtin: "SetFlattenToArray",
+            type_parameters: [this.key_type, elementType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    flattenToSet(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], 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 Expr.fromAst({
+            ast_type: "Builtin",
+            type: SetType(elementType),
+            location: get_location(2),
+            builtin: "SetFlattenToSet",
+            type_parameters: [this.key_type, elementType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    flattenToDict(fn, onConflictFn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], 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 Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(keyType, valueType),
+            location: get_location(2),
+            builtin: "SetFlattenToDict",
+            type_parameters: [this.key_type, keyType, valueType],
+            arguments: [this[AstSymbol], fnAst, onConflictAst],
+        });
+    }
+    groupReduce(keyFn, initFn, reduceFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], 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.key_type], initType, null));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(keyType, initType),
+            location: get_location(2),
+            builtin: "SetGroupFold",
+            type_parameters: [this.key_type, keyType, initType],
+            arguments: [this[AstSymbol], keyFnAst, initFnAst, reduceFnAst],
+        });
+    }
+    groupToArrays(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.key_type], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const valueType = valueFnAst.type.output;
+        return this.groupReduce(((_$, key) => keyFnExpr(key)), ((_$, _groupKey) => Expr.from([], ArrayType(valueType))), (($, acc, key) => {
+            const val = valueFnExpr(key);
+            $(acc.pushLast(val));
+            return acc;
+        }));
+    }
+    groupToSets(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.key_type], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const valueType = valueFnAst.type.output;
+        return this.groupReduce(((_$, key) => keyFnExpr(key)), ((_$, _groupKey) => Expr.from(new Set(), SetType(valueType))), (($, acc, key) => {
+            const val = valueFnExpr(key);
+            $(acc.tryInsert(val));
+            return acc;
+        }));
+    }
+    groupToDicts(keyFn, keyFn2, valueFn, combineFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const keyFn2Ast = valueOrExprToAstTyped(keyFn2, FunctionType([this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.key_type], 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(((_$, key) => keyFnExpr(key)), ((_$, _key) => Expr.from(new Map(), DictType(key2Type, valueType))), (($, dict, key) => {
+                const innerKey = keyFn2Expr(key);
+                const val = valueFnExpr(key);
+                $.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(((_$, key) => keyFnExpr(key)), ((_$, _key) => Expr.from(new Map(), DictType(key2Type, valueType))), (($, dict, key) => {
+                const innerKey = keyFn2Expr(key);
+                const val = valueFnExpr(key);
+                $(dict.insert(innerKey, val));
+                return dict;
+            }));
+        }
+    }
+    groupSize(keyFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, x) => x), FunctionType([this.key_type], undefined, null));
+        return this.toDict(((_$, key) => Expr.fromAst(keyFnAst)(key)), ((_$) => 1n), ((_$, a, b) => a.add(b)));
+    }
+    groupEvery(keyFn, predFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const predFnAst = valueOrExprToAstTyped(predFn, FunctionType([this.key_type], BooleanType, null));
+        return this.groupReduce(((_$, key) => Expr.fromAst(keyFnAst)(key)), (() => true), ((_$, acc, key) => {
+            const pred = Expr.fromAst(predFnAst)(key);
+            return acc.and(() => pred);
+        }));
+    }
+    groupSome(keyFn, predFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const predFnAst = valueOrExprToAstTyped(predFn, FunctionType([this.key_type], BooleanType, null));
+        return this.groupReduce(((_$, key) => Expr.fromAst(keyFnAst)(key)), (() => false), ((_$, acc, key) => {
+            const pred = Expr.fromAst(predFnAst)(key);
+            return acc.or(() => pred);
+        }));
+    }
+    groupSum(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.key_type], 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(((_$, key) => Expr.fromAst(keyFnAst)(key)), ((_$, key) => Expr.fromAst(valueFnAst)(key)), ((_$, a, b) => a.add(b)));
+    }
+    groupMean(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, x) => x), FunctionType([this.key_type], 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(((_$, key) => Expr.fromAst(keyFnAst)(key)), ((_$, key) => {
+            const val = Expr.fromAst(valueFnAst)(key);
+            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())));
+    }
+    // Common reducers are provided, based on reduce
+    /**
+     * Returns true if all elements satisfy a condition (or are true for boolean sets).
+     *
+     * @param fn - Optional predicate function to test each element (required for non-boolean sets)
+     * @returns A BooleanExpr that is true if all elements pass the test, false otherwise
+     *
+     * @remarks
+     * - Empty sets always return true
+     * - Short-circuits on the first false element for efficiency
+     * - For boolean sets, the function parameter can be omitted
+     *
+     * @see {@link some} to check if at least one element satisfies the condition
+     *
+     * @example
+     * ```ts
+     * // Check if all numbers are positive
+     * const allPositive = East.function([SetType(IntegerType)], BooleanType, ($, numbers) => {
+     *   $.return(numbers.every(($, n) => n.greaterThan(0n)));
+     * });
+     * const compiled = East.compile(allPositive.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]));    // true
+     * compiled(new Set([1n, -2n, 3n]));   // false
+     * compiled(new Set([]));              // true (empty set)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // For boolean sets, no function needed
+     * const allTrue = East.function([SetType(BooleanType)], BooleanType, ($, flags) => {
+     *   $.return(flags.every());
+     * });
+     * const compiled = East.compile(allTrue.toIR(), []);
+     * compiled(new Set([true, true]));   // true
+     * compiled(new Set([true, false]));  // false
+     * ```
+     */
+    every(fn) {
+        if (fn === undefined) {
+            if (!isTypeEqual(this.key_type, BooleanType)) {
+                throw new Error(`Can only perform every on set of booleans, got ${printType(this.key_type)}`);
+            }
+            // Short-circuit on first false value - use explicit function AST to avoid type inference issues
+            const optionType = VariantType({ none: NullType, some: NullType });
+            const paramVariable = {
+                ast_type: "Variable",
+                type: this.key_type,
+                location: get_location(2),
+                mutable: false,
+            };
+            // Check if boolean is NOT true, then return some(null) to stop, otherwise return none to continue
+            const notCondition = {
+                ast_type: "Builtin",
+                type: BooleanType,
+                location: get_location(2),
+                builtin: "BooleanNot",
+                type_parameters: [],
+                arguments: [paramVariable]
+            };
+            const checkFnAst = {
+                ast_type: "Function",
+                type: FunctionType([this.key_type], optionType, []),
+                location: get_location(2),
+                parameters: [paramVariable],
+                body: {
+                    ast_type: "IfElse",
+                    type: optionType,
+                    location: get_location(2),
+                    ifs: [{
+                            predicate: notCondition,
+                            body: { ast_type: "Variant", type: optionType, location: get_location(2), case: "some", value: { ast_type: "Value", type: NullType, location: get_location(2), value: null } }
+                        }],
+                    else_body: { ast_type: "Variant", type: optionType, location: get_location(2), case: "none", value: { ast_type: "Value", type: NullType, location: get_location(2), value: null } }
+                }
+            };
+            const result = Expr.fromAst({
+                ast_type: "Builtin",
+                type: optionType,
+                location: get_location(2),
+                builtin: "SetFirstMap",
+                type_parameters: [this.key_type, NullType],
+                arguments: [this[AstSymbol], checkFnAst],
+            });
+            return Expr.match(result, { some: () => false, none: () => true });
+        }
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], BooleanType, null));
+        // Short-circuit on first false value
+        const result = this.firstMap(($, k) => {
+            const result = Expr.fromAst(fnAst)(k);
+            return result.not().ifElse(() => some(null), () => none);
+        });
+        return Expr.match(result, { some: () => false, none: () => true });
+    }
+    /**
+     * Returns true if at least one element satisfies a condition (or is true for boolean sets).
+     *
+     * @param fn - Optional predicate function to test each element (required for non-boolean sets)
+     * @returns A BooleanExpr that is true if any element passes the test, false otherwise
+     *
+     * @remarks
+     * - Empty sets always return false
+     * - Short-circuits on the first true element for efficiency
+     * - For boolean sets, the function parameter can be omitted
+     *
+     * @see {@link every} to check if all elements satisfy the condition
+     *
+     * @example
+     * ```ts
+     * // Check if any number is negative
+     * const hasNegative = East.function([SetType(IntegerType)], BooleanType, ($, numbers) => {
+     *   $.return(numbers.some(($, n) => n.lessThan(0n)));
+     * });
+     * const compiled = East.compile(hasNegative.toIR(), []);
+     * compiled(new Set([1n, 2n, 3n]));    // false
+     * compiled(new Set([1n, -2n, 3n]));   // true
+     * compiled(new Set([]));              // false (empty set)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // For boolean sets, no function needed
+     * const anyTrue = East.function([SetType(BooleanType)], BooleanType, ($, flags) => {
+     *   $.return(flags.some());
+     * });
+     * const compiled = East.compile(anyTrue.toIR(), []);
+     * compiled(new Set([false, false]));  // false
+     * compiled(new Set([false, true]));   // true
+     * ```
+     */
+    some(fn) {
+        if (fn === undefined) {
+            if (!isTypeEqual(this.key_type, BooleanType)) {
+                throw new Error(`Can only perform some on set of booleans, got ${printType(this.key_type)}`);
+            }
+            // Short-circuit on first true value - use explicit function AST to avoid type inference issues
+            const optionType = VariantType({ none: NullType, some: NullType });
+            const paramVariable = {
+                ast_type: "Variable",
+                type: this.key_type,
+                location: get_location(2),
+                mutable: false,
+            };
+            // Check if boolean is true, then return some(null) to stop, otherwise return none to continue
+            const checkFnAst = {
+                ast_type: "Function",
+                type: FunctionType([this.key_type], optionType, []),
+                location: get_location(2),
+                parameters: [paramVariable],
+                body: {
+                    ast_type: "IfElse",
+                    type: optionType,
+                    location: get_location(2),
+                    ifs: [{
+                            predicate: paramVariable,
+                            body: { ast_type: "Variant", type: optionType, location: get_location(2), case: "some", value: { ast_type: "Value", type: NullType, location: get_location(2), value: null } }
+                        }],
+                    else_body: { ast_type: "Variant", type: optionType, location: get_location(2), case: "none", value: { ast_type: "Value", type: NullType, location: get_location(2), value: null } }
+                }
+            };
+            const result = Expr.fromAst({
+                ast_type: "Builtin",
+                type: optionType,
+                location: get_location(2),
+                builtin: "SetFirstMap",
+                type_parameters: [this.key_type, NullType],
+                arguments: [this[AstSymbol], checkFnAst],
+            });
+            return Expr.match(result, { some: () => true, none: () => false });
+        }
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], BooleanType, null));
+        // Short-circuit on first true value
+        const result = this.firstMap(($, k) => {
+            const result = Expr.fromAst(fnAst)(k);
+            return result.ifElse(() => some(null), () => none);
+        });
+        return Expr.match(result, { some: () => true, none: () => false });
+    }
+    sum(fn) {
+        if (fn === undefined) {
+            if (!(isTypeEqual(this.key_type, IntegerType) || isTypeEqual(this.key_type, FloatType))) {
+                throw new Error(`Can only perform sum on set of numbers (Integer or Float), got ${printType(this.key_type)}`);
+            }
+            const zero = isTypeEqual(this.key_type, IntegerType) ? 0n : 0.0;
+            return this.reduce(($, previous, value) => previous.add(value), zero);
+        }
+        else {
+            const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], 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, key) => previous.add(Expr.fromAst(fnAst)(key)), zero);
+        }
+    }
+    mean(fn) {
+        if (fn === undefined) {
+            if (isTypeEqual(this.key_type, IntegerType)) {
+                return this.reduce(($, previous, value) => previous.add(value.toFloat()), 0.0).divide(this.size().toFloat());
+            }
+            else if (isTypeEqual(this.key_type, FloatType)) {
+                return this.reduce(($, previous, value) => previous.add(value), 0.0).divide(this.size().toFloat());
+            }
+            else {
+                throw new Error(`Can only perform mean on set of numbers (Integer or Float), got ${printType(this.key_type)}`);
+            }
+        }
+        else {
+            const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.key_type], undefined, null));
+            const returnType = fnAst.type.output;
+            if (isTypeEqual(returnType, IntegerType)) {
+                return this.reduce(($, previous, key) => previous.add(Expr.fromAst(fnAst)(key).toFloat()), 0.0).divide(this.size().toFloat());
+            }
+            else if (isTypeEqual(returnType, FloatType)) {
+                return this.reduce(($, previous, key) => previous.add(Expr.fromAst(fnAst)(key)), 0.0).divide(this.size().toFloat());
+            }
+            else {
+                throw new Error(`Can only perform mean on set of numbers (Integer or Float), got ${printType(returnType)}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=set.js.map