@elaraai/east 0.0.1-beta.0

package/dist/src/expr/dict.js

@@ -0,0 +1,1492 @@
+import { get_location } from "../location.js";
+import { DictType, BooleanType, FunctionType, IntegerType, NullType, OptionType, SetType, NeverType, VariantType, printType, FloatType, isTypeEqual, ArrayType } 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 dictionary (key-value map) values and operations.
+ *
+ * DictExpr provides methods for working with sorted dictionaries (maps) including lookup,
+ * insertion, deletion, iteration, mapping, filtering, grouping, and aggregation operations.
+ * Dictionaries maintain their entries sorted by key using East's total ordering.
+ *
+ * @example
+ * ```ts
+ * // Creating and manipulating dictionaries
+ * const updateCounts = East.function([DictType(StringType, IntegerType), StringType], DictType(StringType, IntegerType), ($, counts, word) => {
+ *   // Increment count for a word, initializing to 0 if missing
+ *   $.return(counts.merge(word, 1n, ($, existing, increment) => existing.add(increment), () => 0n));
+ * });
+ * const compiled = East.compile(updateCounts.toIR(), []);
+ * const counts = new Map([["hello", 5n], ["world", 3n]]);
+ * compiled(counts, "hello");  // Map([["hello", 6n], ["world", 3n]])
+ * compiled(counts, "new");    // Map([["hello", 6n], ["new", 1n], ["world", 3n]])
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Filtering and mapping
+ * const filterHighScores = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, scores) => {
+ *   $.return(scores.filter(($, score, name) => score.greaterOrEqual(100n)));
+ * });
+ * const compiled = East.compile(filterHighScores.toIR(), []);
+ * const scores = new Map([["alice", 150n], ["bob", 75n], ["charlie", 200n]]);
+ * compiled(scores);  // Map([["alice", 150n], ["charlie", 200n]])
+ * ```
+ */
+export class DictExpr extends Expr {
+    key_type;
+    value_type;
+    constructor(key_type, value_type, ast, createExpr) {
+        super(ast.type, ast, createExpr);
+        this.key_type = key_type;
+        this.value_type = value_type;
+    }
+    /**
+     * Returns the number of key-value pairs in the dictionary.
+     *
+     * @returns An IntegerExpr representing the count of entries
+     *
+     * @example
+     * ```ts
+     * const getSize = East.function([DictType(StringType, IntegerType)], IntegerType, ($, dict) => {
+     *   $.return(dict.size());
+     * });
+     * const compiled = East.compile(getSize.toIR(), []);
+     * compiled(new Map([["a", 1n], ["b", 2n], ["c", 3n]]));  // 3n
+     * compiled(new Map());  // 0n
+     * ```
+     */
+    size() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: IntegerType,
+            location: get_location(2),
+            builtin: "DictSize",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Checks if a key exists in the dictionary.
+     *
+     * @param key - The key to search for
+     * @returns A BooleanExpr that is true if the key exists, false otherwise
+     *
+     * @example
+     * ```ts
+     * const hasKey = East.function([DictType(StringType, IntegerType), StringType], BooleanType, ($, dict, key) => {
+     *   $.return(dict.has(key));
+     * });
+     * const compiled = East.compile(hasKey.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a");     // true
+     * compiled(dict, "c");     // false
+     * ```
+     */
+    has(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "DictHas",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Gets the value associated with a key in the dictionary.
+     *
+     * @param key - The key to look up
+     * @param onMissing - Optional function to call if key is not found; if omitted, an error is thrown on missing key
+     * @returns An expression of the value type
+     *
+     * @throws East runtime error if key is not found and onMissing is not provided
+     *
+     * @see {@link tryGet} for a safe lookup that returns an Option type
+     * @see {@link getOrInsert} to insert a default value if the key is missing
+     *
+     * @example
+     * ```ts
+     * const getValue = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
+     *   $.return(dict.get(key));
+     * });
+     * const compiled = East.compile(getValue.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a");  // 1n
+     * // compiled(dict, "c") would throw error
+     * ```
+     *
+     * @example
+     * ```ts
+     * // With missing handler
+     * const getWithDefault = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
+     *   $.return(dict.get(key, () => -1n));
+     * });
+     * const compiled = East.compile(getWithDefault.toIR(), []);
+     * compiled(dict, "a");  // 1n
+     * compiled(dict, "c");  // -1n
+     * ```
+     */
+    get(key, onMissing) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        if (onMissing === undefined) {
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: this.value_type,
+                location: get_location(2),
+                builtin: "DictGet",
+                type_parameters: [this.key_type, this.value_type],
+                arguments: [this[AstSymbol], keyAst],
+            });
+        }
+        else {
+            const onMissingExpr = Expr.from(onMissing, FunctionType([this.key_type], this.value_type, null));
+            const onMissingAst = Expr.ast(onMissingExpr);
+            return this[FactorySymbol]({
+                ast_type: "Builtin",
+                type: this.value_type,
+                location: get_location(2),
+                builtin: "DictGetOrDefault",
+                type_parameters: [this.key_type, this.value_type],
+                arguments: [this[AstSymbol], keyAst, onMissingAst],
+            });
+        }
+    }
+    /**
+     * Safely gets a value from the dictionary, returning an Option type.
+     *
+     * @param key - The key to look up
+     * @returns An Option containing the value if found (.some(value)), or .none if not found
+     *
+     * @see {@link get} for a version that throws an error on missing keys
+     *
+     * @example
+     * ```ts
+     * const tryGetValue = East.function([DictType(StringType, IntegerType), StringType], OptionType(IntegerType), ($, dict, key) => {
+     *   $.return(dict.tryGet(key));
+     * });
+     * const compiled = East.compile(tryGetValue.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a");  // { tag: "some", value: 1n }
+     * compiled(dict, "c");  // { tag: "none", value: null }
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Using with match
+     * const getOrDefault = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
+     *   $.return($.match(dict.tryGet(key), {
+     *     some: ($, value) => value,
+     *     none: () => 0n
+     *   }));
+     * });
+     * const compiled = East.compile(getOrDefault.toIR(), []);
+     * compiled(dict, "a");  // 1n
+     * compiled(dict, "c");  // 0n
+     * ```
+     */
+    tryGet(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: OptionType(this.value_type),
+            location: get_location(2),
+            builtin: "DictTryGet",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Inserts a new key-value pair into the dictionary.
+     *
+     * @param key - The key to insert
+     * @param value - The value to associate with the key
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if the key already exists in the dictionary
+     *
+     * @see {@link update} for replacing an existing value
+     * @see {@link insertOrUpdate} for inserting or updating without error
+     * @see {@link getOrInsert} to insert a value lazily on lookup
+     *
+     * @example
+     * ```ts
+     * const insertEntry = East.function([DictType(StringType, IntegerType), StringType, IntegerType], NullType, ($, dict, key, value) => {
+     *   $(dict.insert(key, value));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(insertEntry.toIR(), []);
+     * const dict = new Map([["a", 1n]]);
+     * compiled(dict, "b", 2n);  // dict now has Map([["a", 1n], ["b", 2n]])
+     * // compiled(dict, "a", 10n) would throw error (duplicate key)
+     * ```
+     */
+    insert(key, value) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictInsert",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst, valueAst],
+        });
+    }
+    /**
+     * Inserts or updates a key-value pair in the dictionary.
+     *
+     * If the key already exists, the value is overwritten with the provided value. This operation is idempotent.
+     *
+     * @param key - The key to insert or update
+     * @param value - The new value to associate with the key
+     * @returns A NullExpr
+     *
+     * @see {@link insert} for inserting only (errors on duplicate)
+     * @see {@link update} for updating only (errors on missing key)
+     *
+     * @example
+     * ```ts
+     * const upsert = East.function([DictType(StringType, IntegerType), StringType, IntegerType], NullType, ($, dict, key, value) => {
+     *   $(dict.insertOrUpdate(key, value));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(upsert.toIR(), []);
+     * const dict = new Map([["a", 1n]]);
+     * compiled(dict, "b", 2n);   // dict now has Map([["a", 1n], ["b", 2n]])
+     * compiled(dict, "a", 10n);  // dict now has Map([["a", 10n], ["b", 2n]])
+     * ```
+     */
+    insertOrUpdate(key, value) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictInsertOrUpdate",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst, valueAst],
+        });
+    }
+    /**
+     * Updates an existing value in the dictionary.
+     *
+     * @param key - The key to update
+     * @param value - The new value to set
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if the key does not exist
+     *
+     * @see {@link insertOrUpdate} for inserting or updating without error
+     * @see {@link getOrInsert} to get or insert a value
+     * @see {@link merge} to update based on the existing value
+     *
+     * @example
+     * ```ts
+     * const updateValue = East.function([DictType(StringType, IntegerType), StringType, IntegerType], NullType, ($, dict, key, newValue) => {
+     *   $(dict.update(key, newValue));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(updateValue.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a", 10n);  // dict now has Map([["a", 10n], ["b", 2n]])
+     * // compiled(dict, "c", 3n) would throw error (key not found)
+     * ```
+     */
+    update(key, value) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictUpdate",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst, valueAst],
+        });
+    }
+    /**
+     * Modifies a dictionary value at a key by merging it with a new value.
+     *
+     * This is useful for patterns where you want to update an entry based on its current value, e.g. incrementing a number,
+     * appending to a string, updating fields in a struct, or pushing to an array.
+     *
+     * @param key - The key to update
+     * @param value - The value to merge with the existing value
+     * @param updateFn - Function accepting (existing, new, key) and returning the merged value
+     * @param initialFn - Optional function to produce an initial value if key is missing; if omitted, an error is thrown on missing key
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if key is not found and initialFn is not provided
+     *
+     * @see {@link insertOrUpdate} and {@link update} for simply replacing the value
+     *
+     * @example
+     * ```ts
+     * // Increment counter, initializing to 0 if missing
+     * const increment = East.function([DictType(StringType, IntegerType), StringType], NullType, ($, counts, word) => {
+     *   $(counts.merge(word, 1n, ($, existing, inc) => existing.add(inc), () => 0n));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(increment.toIR(), []);
+     * const counts = new Map([["hello", 5n]]);
+     * compiled(counts, "hello");  // counts now has Map([["hello", 6n]])
+     * compiled(counts, "world");  // counts now has Map([["hello", 6n], ["world", 1n]])
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Append to string
+     * const appendText = East.function([DictType(StringType, StringType), StringType, StringType], NullType, ($, dict, key, suffix) => {
+     *   $(dict.merge(key, suffix, ($, existing, newVal) => existing.concat(newVal), () => ""));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(appendText.toIR(), []);
+     * const dict = new Map([["greeting", "Hello"]]);
+     * compiled(dict, "greeting", " World");  // Map([["greeting", "Hello World"]])
+     * compiled(dict, "new", "Hi");           // Map([["greeting", "Hello World"], ["new", "Hi"]])
+     * ```
+     */
+    merge(key, value, updateFn, initialFn) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        const valueAst = valueOrExprToAst(value);
+        const value2Type = valueAst.type;
+        const updateFnExpr = Expr.from(updateFn, FunctionType([this.value_type, value2Type, this.key_type], this.value_type, null));
+        let initialExpr;
+        if (initialFn === undefined) {
+            // Default: create function that throws error
+            initialExpr = Expr.function([this.key_type], this.value_type, ($, key) => $.error(Expr.str `Key ${key} not found in dictionary`, get_location(2)));
+        }
+        else {
+            initialExpr = Expr.from(initialFn, FunctionType([this.key_type], this.value_type, null));
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictMerge",
+            type_parameters: [this.key_type, this.value_type, value2Type],
+            arguments: [this[AstSymbol], keyAst, valueAst, Expr.ast(updateFnExpr), Expr.ast(initialExpr)],
+        });
+    }
+    /**
+     * Gets a value from the dictionary or inserts it if the key is not present.
+     *
+     * The default value is evaluated and inserted if the key is not present, otherwise the existing value is returned.
+     *
+     * @param key - The key to get or insert
+     * @param defaultValue - Function that computes the default value if key is missing
+     * @returns The existing value or the newly inserted value
+     *
+     * @see {@link get} for getting with a missing handler
+     * @see {@link insert} for inserting with a conflict handler
+     * @see {@link update} for updating existing values
+     *
+     * @example
+     * ```ts
+     * const getOrCreate = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
+     *   $.return(dict.getOrInsert(key, () => 0n));
+     * });
+     * const compiled = East.compile(getOrCreate.toIR(), []);
+     * const dict = new Map([["a", 1n]]);
+     * compiled(dict, "a");  // 1n (existing value)
+     * compiled(dict, "b");  // 0n (new value inserted)
+     * // dict now has Map([["a", 1n], ["b", 0n]])
+     * ```
+     */
+    getOrInsert(key, defaultValue) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        const defaultValueExpr = Expr.from(defaultValue, FunctionType([this.key_type], this.value_type, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this.value_type,
+            location: get_location(2),
+            builtin: "DictGetOrInsert",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst, Expr.ast(defaultValueExpr)],
+        });
+    }
+    /**
+     * Deletes a key from the dictionary.
+     *
+     * @param key - The key to delete
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if the key does not exist
+     *
+     * @see {@link tryDelete} for a version that doesn't error on missing keys
+     * @see {@link clear} to remove all keys
+     * @see {@link pop} to delete and return the value
+     *
+     * @example
+     * ```ts
+     * const deleteKey = East.function([DictType(StringType, IntegerType), StringType], NullType, ($, dict, key) => {
+     *   $(dict.delete(key));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(deleteKey.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a");  // dict now has Map([["b", 2n]])
+     * // compiled(dict, "c") would throw error (key not found)
+     * ```
+     */
+    delete(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictDelete",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Tries to delete a key from the dictionary, returning whether it was deleted.
+     *
+     * @param key - The key to delete
+     * @returns A BooleanExpr that is true if the key was deleted, false if not found
+     *
+     * @see {@link delete} for a version that errors on missing keys
+     * @see {@link clear} to remove all keys
+     *
+     * @example
+     * ```ts
+     * const tryDeleteKey = East.function([DictType(StringType, IntegerType), StringType], BooleanType, ($, dict, key) => {
+     *   $.return(dict.tryDelete(key));
+     * });
+     * const compiled = East.compile(tryDeleteKey.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a");  // true (dict now has Map([["b", 2n]]))
+     * compiled(dict, "c");  // false (key not found, dict unchanged)
+     * ```
+     */
+    tryDelete(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: BooleanType,
+            location: get_location(2),
+            builtin: "DictTryDelete",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Removes a key from the dictionary and returns its value.
+     *
+     * @param key - The key to pop
+     * @returns The value that was associated with the key
+     *
+     * @throws East runtime error if the key does not exist
+     *
+     * @see {@link delete} to remove a key without returning the value
+     * @see {@link swap} to replace a value and return the old one
+     *
+     * @example
+     * ```ts
+     * const popKey = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
+     *   $.return(dict.pop(key));
+     * });
+     * const compiled = East.compile(popKey.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a");  // 1n (dict now has Map([["b", 2n]]))
+     * // compiled(dict, "c") would throw error (key not found)
+     * ```
+     */
+    pop(key) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this.value_type,
+            location: get_location(2),
+            builtin: "DictPop",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst],
+        });
+    }
+    /**
+     * Swaps a value in the dictionary, returning the previous value.
+     *
+     * @param key - The key to swap
+     * @param value - The new value to insert
+     * @returns The previous value that was associated with the key
+     *
+     * @throws East runtime error if the key does not exist
+     *
+     * @see {@link pop} to remove a key and return its value
+     * @see {@link update} to update without returning the old value
+     *
+     * @example
+     * ```ts
+     * const swapValue = East.function([DictType(StringType, IntegerType), StringType, IntegerType], IntegerType, ($, dict, key, newValue) => {
+     *   $.return(dict.swap(key, newValue));
+     * });
+     * const compiled = East.compile(swapValue.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict, "a", 10n);  // 1n (dict now has Map([["a", 10n], ["b", 2n]]))
+     * // compiled(dict, "c", 3n) would throw error (key not found)
+     * ```
+     */
+    swap(key, value) {
+        const keyAst = valueOrExprToAstTyped(key, this.key_type);
+        const valueAst = valueOrExprToAstTyped(value, this.value_type);
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this.value_type,
+            location: get_location(2),
+            builtin: "DictSwap",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keyAst, valueAst],
+        });
+    }
+    /**
+     * Removes all keys from the dictionary.
+     *
+     * @returns A NullExpr
+     *
+     * @see {@link delete} or {@link tryDelete} to remove individual keys
+     *
+     * @example
+     * ```ts
+     * const clearDict = East.function([DictType(StringType, IntegerType)], NullType, ($, dict) => {
+     *   $(dict.clear());
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(clearDict.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
+     * compiled(dict);  // dict is now Map([])
+     * ```
+     */
+    clear() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictClear",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Unions another dictionary into this one in place.
+     *
+     * If a key exists in both dictionaries, a merger function can be provided to combine the values.
+     * Without a merger function, an error is thrown on overlapping keys.
+     *
+     * @param dict2 - The dictionary to union with this one
+     * @param mergeFn - Optional function to combine values when keys overlap; accepts (existing, new, key) and returns merged value
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if keys overlap and mergeFn is not provided
+     *
+     * @see {@link mergeAll} for a more general merge operation with different value types
+     *
+     * @example
+     * ```ts
+     * const unionDicts = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], NullType, ($, dict1, dict2) => {
+     *   $(dict1.unionInPlace(dict2, ($, existing, newVal) => existing.add(newVal)));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(unionDicts.toIR(), []);
+     * const dict1 = new Map([["a", 1n], ["b", 2n]]);
+     * const dict2 = new Map([["b", 3n], ["c", 4n]]);
+     * compiled(dict1, dict2);  // dict1 now has Map([["a", 1n], ["b", 5n], ["c", 4n]])
+     * ```
+     */
+    unionInPlace(dict2, mergeFn) {
+        const dict2Expr = Expr.from(dict2, this[TypeSymbol]);
+        let mergerAst;
+        if (mergeFn === undefined) {
+            // Default: replace existing value with new value (ignore key and existing, return new)
+            const mergerExpr = Expr.function([this.value_type, this.value_type, this.key_type], this.value_type, ($, _v1, _v2, k) => $.error(Expr.str `Key ${k} exists in both dictionaries`, get_location(2)));
+            mergerAst = Expr.ast(mergerExpr);
+        }
+        else {
+            const mergerExpr = Expr.from(mergeFn, FunctionType([this.value_type, this.value_type, this.key_type], this.value_type, null));
+            mergerAst = Expr.ast(mergerExpr);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictUnionInPlace",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], Expr.ast(dict2Expr), mergerAst],
+        });
+    }
+    /**
+     * Merges all values from another dictionary into this one using a merge function.
+     *
+     * The type of the other dictionary can be different from this one, so long as the merge function can combine
+     * the two value types into this dictionary's value type. This is useful for patterns like merging counts from
+     * multiple dictionaries, pushing to nested arrays, or partially updating dictionaries-of-structs.
+     *
+     * @param dict2 - The dictionary whose values to merge into this one
+     * @param mergeFn - Function accepting (existing, new, key) and returning the merged value
+     * @param initialFn - Optional function to produce initial value for missing keys; if omitted, an error is thrown on missing key
+     * @returns A NullExpr
+     *
+     * @throws East runtime error if a key is missing and initialFn is not provided
+     *
+     * @see {@link unionInPlace} for merging dictionaries of the same type
+     * @see {@link merge} to merge a single key
+     *
+     * @example
+     * ```ts
+     * // Merge counts from two dictionaries
+     * const mergeCounts = East.function(
+     *   [DictType(StringType, IntegerType), DictType(StringType, IntegerType)],
+     *   NullType,
+     *   ($, counts1, counts2) => {
+     *     $(counts1.mergeAll(counts2, ($, existing, newVal) => existing.add(newVal), () => 0n));
+     *     $.return(null);
+     *   }
+     * );
+     * const compiled = East.compile(mergeCounts.toIR(), []);
+     * const counts1 = new Map([["apple", 5n], ["banana", 3n]]);
+     * const counts2 = new Map([["banana", 2n], ["cherry", 7n]]);
+     * compiled(counts1, counts2);  // counts1 now has Map([["apple", 5n], ["banana", 5n], ["cherry", 7n]])
+     * ```
+     */
+    mergeAll(dict2, mergeFn, initialFn) {
+        const dict2Ast = Expr.ast(dict2);
+        const value2Type = dict2Ast.type.value;
+        const mergerExpr = Expr.from(mergeFn, FunctionType([this.value_type, value2Type, this.key_type], this.value_type, null));
+        let initialExpr;
+        if (initialFn === undefined) {
+            // Default: create function that throws error
+            initialExpr = Expr.function([this.key_type], this.value_type, ($, key) => $.error(Expr.str `Key ${key} not found in dictionary`, get_location(2)));
+        }
+        else {
+            initialExpr = Expr.from(initialFn, FunctionType([this.key_type], this.value_type, null));
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictMergeAll",
+            type_parameters: [this.key_type, this.value_type, value2Type],
+            arguments: [this[AstSymbol], dict2Ast, Expr.ast(mergerExpr), Expr.ast(initialExpr)],
+        });
+    }
+    /**
+     * Returns a set containing all keys in the dictionary.
+     *
+     * @returns A SetExpr containing all the dictionary's keys
+     *
+     * @see {@link getKeys} to get values for a subset of keys
+     *
+     * @example
+     * ```ts
+     * const getKeys = East.function([DictType(StringType, IntegerType)], SetType(StringType), ($, dict) => {
+     *   $.return(dict.keys());
+     * });
+     * const compiled = East.compile(getKeys.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
+     * compiled(dict);  // Set(["a", "b", "c"])
+     * ```
+     */
+    keys() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: SetType(this.key_type),
+            location: get_location(2),
+            builtin: "DictKeys",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    /**
+     * Collects the values associated with the given keys in a new dictionary.
+     *
+     * @param keys - Set of keys to look up
+     * @param onMissing - Optional function to produce values for missing keys; if omitted, an error is thrown on missing key
+     * @returns A new dictionary containing only the specified keys
+     *
+     * @throws East runtime error if a key is not found and onMissing is not provided
+     *
+     * @see {@link keys} to get all keys as a set
+     *
+     * @example
+     * ```ts
+     * const selectKeys = East.function([DictType(StringType, IntegerType), SetType(StringType)], DictType(StringType, IntegerType), ($, dict, keysToSelect) => {
+     *   $.return(dict.getKeys(keysToSelect));
+     * });
+     * const compiled = East.compile(selectKeys.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n], ["d", 4n]]);
+     * const keysToSelect = new Set(["a", "c"]);
+     * compiled(dict, keysToSelect);  // Map([["a", 1n], ["c", 3n]])
+     * ```
+     *
+     * @example
+     * ```ts
+     * // With missing handler
+     * const selectWithDefault = East.function([DictType(StringType, IntegerType), SetType(StringType)], DictType(StringType, IntegerType), ($, dict, keys) => {
+     *   $.return(dict.getKeys(keys, () => 0n));
+     * });
+     * const compiled = East.compile(selectWithDefault.toIR(), []);
+     * const keysWithMissing = new Set(["a", "x"]);
+     * compiled(dict, keysWithMissing);  // Map([["a", 1n], ["x", 0n]])
+     * ```
+     */
+    getKeys(keys, onMissing) {
+        const keysAst = valueOrExprToAstTyped(keys, SetType(this.key_type));
+        let onMissingAst;
+        if (onMissing === undefined) {
+            // Default: throw error with key information if key doesn't exist
+            const defaultFunction = Expr.function([this.key_type], this.value_type, ($, key) => $.error(Expr.str `Key ${key} not found in dictionary`, get_location(2)));
+            onMissingAst = Expr.ast(defaultFunction);
+        }
+        else {
+            const onMissingExpr = Expr.from(onMissing, FunctionType([this.key_type], this.value_type, null));
+            onMissingAst = Expr.ast(onMissingExpr);
+        }
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "DictGetKeys",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], keysAst, onMissingAst],
+        });
+    }
+    /**
+     * Iterates over each key-value pair in the dictionary, applying a function to each.
+     *
+     * @param fn - Function to apply to each (value, key) pair
+     * @returns A NullExpr
+     *
+     * @example
+     * ```ts
+     * const printEntries = East.function([DictType(StringType, IntegerType)], NullType, ($, dict) => {
+     *   $(dict.forEach(($, value, key) => {
+     *     // In a real platform, you could use a platform function to log
+     *     // For this example, we just demonstrate the iteration structure
+     *   }));
+     *   $.return(null);
+     * });
+     * const compiled = East.compile(printEntries.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * compiled(dict);  // Iterates over all entries
+     * ```
+     */
+    forEach(fn) {
+        let fnAst;
+        if (typeof fn === "function") {
+            const fnExpr = Expr.function([this.value_type, this.key_type], undefined, fn);
+            fnAst = Expr.ast(fnExpr);
+        }
+        else {
+            const fnExpr = Expr.from(fn, FunctionType([this.value_type, this.key_type], undefined, null));
+            fnAst = Expr.ast(fnExpr);
+        }
+        const returnType = fnAst.type.output;
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: NullType,
+            location: get_location(2),
+            builtin: "DictForEach",
+            type_parameters: [this.key_type, this.value_type, returnType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    /**
+     * Creates a shallow copy of the dictionary.
+     *
+     * @returns A new DictExpr containing the same key-value pairs
+     *
+     * @example
+     * ```ts
+     * const copyDict = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict) => {
+     *   $.return(dict.copy());
+     * });
+     * const compiled = East.compile(copyDict.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n]]);
+     * const copy = compiled(dict);  // Map([["a", 1n], ["b", 2n]])
+     * // Modifying copy doesn't affect dict
+     * ```
+     */
+    copy() {
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "DictCopy",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol]],
+        });
+    }
+    map(fn) {
+        let fnExpr;
+        if (typeof fn === "function") {
+            fnExpr = Expr.function([this.value_type, this.key_type], undefined, fn);
+        }
+        else {
+            fnExpr = fn;
+        }
+        const fnAst = Expr.ast(fnExpr);
+        const returnType = fnAst.type.output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(this.key_type, returnType),
+            location: get_location(2),
+            builtin: "DictMap",
+            type_parameters: [this.key_type, this.value_type, returnType],
+            arguments: [this[AstSymbol], Expr.ast(fnExpr)],
+        });
+    }
+    /**
+     * Filters the dictionary by applying a predicate function to each entry.
+     *
+     * @param fn - Predicate function that returns true to keep an entry, false to discard it
+     * @returns A new DictExpr containing only entries for which the predicate returned true
+     *
+     * @see {@link filterMap} to filter and map in one operation
+     * @see {@link map} to transform values without filtering
+     *
+     * @example
+     * ```ts
+     * const filterLargeValues = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict) => {
+     *   $.return(dict.filter(($, value, key) => value.greaterOrEqual(10n)));
+     * });
+     * const compiled = East.compile(filterLargeValues.toIR(), []);
+     * const dict = new Map([["a", 5n], ["b", 15n], ["c", 20n], ["d", 8n]]);
+     * compiled(dict);  // Map([["b", 15n], ["c", 20n]])
+     * ```
+     */
+    filter(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, this.key_type], BooleanType, null));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "DictFilter",
+            type_parameters: [this.key_type, this.value_type],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    filterMap(fn) {
+        let fnExpr;
+        if (typeof fn === "function") {
+            fnExpr = Expr.function([this.value_type, this.key_type], undefined, fn);
+        }
+        else {
+            fnExpr = fn;
+        }
+        const fnAst = Expr.ast(fnExpr);
+        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: this[TypeSymbol],
+            location: get_location(2),
+            builtin: "DictFilterMap",
+            type_parameters: [this.key_type, this.value_type, someType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    toArray(fn) {
+        let fnExpr;
+        if (fn === undefined) {
+            // Identity function
+            fnExpr = Expr.function([this.value_type, this.key_type], this.value_type, ($, value) => value);
+        }
+        else if (typeof fn === "function") {
+            fnExpr = Expr.function([this.value_type, 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: "DictToArray",
+            type_parameters: [this.key_type, this.value_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.value_type, this.key_type], undefined, keyFn);
+            }
+            else {
+                fnExpr = keyFn;
+            }
+            keyFnAst = Expr.ast(fnExpr);
+        }
+        else {
+            // Identity function
+            const identityFunction = Expr.function([this.value_type, this.key_type], this.value_type, ($, value) => value);
+            keyFnAst = Expr.ast(identityFunction);
+        }
+        const keyType = keyFnAst.type.output;
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: SetType(keyType),
+            location: get_location(2),
+            builtin: "DictToSet",
+            type_parameters: [this.key_type, this.value_type, keyType],
+            arguments: [this[AstSymbol], keyFnAst],
+        });
+    }
+    toDict(keyFn, valueFn, onConflictFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, v, k) => k), FunctionType([this.value_type, this.key_type], undefined, null));
+        const keyType = keyFnAst.type.output;
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, v) => v), FunctionType([this.value_type, 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: "DictToDict",
+            type_parameters: [this.key_type, this.value_type, keyType, valueType],
+            arguments: [this[AstSymbol], keyFnAst, valueFnAst, onConflictAst],
+        });
+    }
+    flattenToArray(fn) {
+        const fnAst = valueOrExprToAstTyped(fn ?? ((_$, x) => x), FunctionType([this.value_type, 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: "DictFlattenToArray",
+            type_parameters: [this.key_type, this.value_type, elementType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    flattenToSet(fn) {
+        const fnAst = valueOrExprToAstTyped(fn ?? ((_$, x) => x), FunctionType([this.value_type, 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: "DictFlattenToSet",
+            type_parameters: [this.key_type, this.value_type, elementType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    flattenToDict(fn, onConflictFn) {
+        const fnAst = valueOrExprToAstTyped(fn ?? ((_$, x) => x), FunctionType([this.value_type, 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: "DictFlattenToDict",
+            type_parameters: [this.key_type, this.value_type, keyType, valueType],
+            arguments: [this[AstSymbol], fnAst, onConflictAst],
+        });
+    }
+    groupReduce(keyFn, initFn, reduceFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, 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.value_type, this.key_type], initType, null));
+        return Expr.fromAst({
+            ast_type: "Builtin",
+            type: DictType(keyType, initType),
+            location: get_location(2),
+            builtin: "DictGroupFold",
+            type_parameters: [this.key_type, this.value_type, keyType, initType],
+            arguments: [this[AstSymbol], keyFnAst, initFnAst, reduceFnAst],
+        });
+    }
+    /**
+     * Collect entries in each group into arrays.
+     *
+     * @param keyFn - Function that computes the grouping key
+     * @param valueFn - Optional projection function for values
+     * @returns Dictionary mapping each key to an array of elements in that group
+     *
+     * @example
+     * ```ts
+     * new Dict({ a: 1n, b: 2n, c: 3n, d: 4n }).groupToArrays(($, v, k) => v.remainder(2n))
+     * // Result: { 0n: [2n, 4n], 1n: [1n, 3n] }
+     * ```
+     */
+    groupToArrays(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, v) => v), FunctionType([this.value_type, this.key_type], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const valueType = valueFnAst.type.output;
+        return this.groupReduce(((_$, value, key) => keyFnExpr(value, key)), ((_$, _groupKey) => Expr.from([], ArrayType(valueType))), (($, acc, value, key) => {
+            const val = valueFnExpr(value, key);
+            $(acc.pushLast(val));
+            return acc;
+        }));
+    }
+    /**
+     * Collect entries in each group into sets, ignoring duplicates.
+     *
+     * @param keyFn - Function that computes the grouping key
+     * @param valueFn - Optional projection function for values
+     * @returns Dictionary mapping each key to a set of elements in that group
+     *
+     * @example
+     * ```ts
+     * new Dict({ a: 1n, b: 2n, c: 1n, d: 2n }).groupToSets(($, v, k) => v.remainder(2n))
+     * // Result: { 0n: Set([2n]), 1n: Set([1n]) }
+     * ```
+     */
+    groupToSets(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, v) => v), FunctionType([this.value_type, this.key_type], undefined, null));
+        const keyFnExpr = Expr.fromAst(keyFnAst);
+        const valueFnExpr = Expr.fromAst(valueFnAst);
+        const valueType = valueFnAst.type.output;
+        return this.groupReduce(((_$, value, key) => keyFnExpr(value, key)), ((_$, _groupKey) => Expr.from(new Set(), SetType(valueType))), (($, acc, value, key) => {
+            const val = valueFnExpr(value, key);
+            $(acc.tryInsert(val));
+            return acc;
+        }));
+    }
+    /**
+     * Group entries into nested dictionaries.
+     *
+     * @param keyFn - Function that computes the outer grouping key
+     * @param keyFn2 - Function that computes the inner dictionary key
+     * @param valueFn - Optional projection function for inner dictionary values
+     * @param combineFn - Optional function to resolve conflicts when the same inner key appears multiple times
+     * @returns Dictionary-of-dictionaries mapping group keys to dictionaries
+     *
+     * @example
+     * ```ts
+     * // Without conflict handler - errors on duplicate keys
+     * orders.groupToDicts(
+     *   ($, v, k) => v.department,
+     *   ($, v, k) => v.role
+     * )
+     * // Result: { "eng": { "dev": user1, "lead": user2 }, "sales": { "rep": user3 } }
+     *
+     * // With conflict handler - merges duplicate keys
+     * orders.groupToDicts(
+     *   ($, v, k) => v.customer,
+     *   ($, v, k) => v.product,
+     *   ($, v, k) => v.quantity,
+     *   ($, a, b) => a.add(b)
+     * )
+     * // Sums quantities for same customer+product
+     * ```
+     */
+    groupToDicts(keyFn, keyFn2, valueFn, combineFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const keyFn2Ast = valueOrExprToAstTyped(keyFn2, FunctionType([this.value_type, this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, v) => v), FunctionType([this.value_type, 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(((_$, value, key) => keyFnExpr(value, key)), ((_$, _groupKey) => Expr.from(new Map(), DictType(key2Type, valueType))), (($, dict, value, key) => {
+                const innerKey = keyFn2Expr(value, key);
+                const val = valueFnExpr(value, 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(((_$, value, key) => keyFnExpr(value, key)), ((_$, _groupKey) => Expr.from(new Map(), DictType(key2Type, valueType))), (($, dict, value, key) => {
+                const innerKey = keyFn2Expr(value, key);
+                const val = valueFnExpr(value, key);
+                $(dict.insert(innerKey, val));
+                return dict;
+            }));
+        }
+    }
+    groupSize(keyFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn ?? ((_$, v) => v), FunctionType([this.value_type, this.key_type], undefined, null));
+        return this.toDict(((_$, value, key) => Expr.fromAst(keyFnAst)(value, key)), ((_$) => 1n), ((_$, a, b) => a.add(b)));
+    }
+    groupEvery(keyFn, predFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const predFnAst = valueOrExprToAstTyped(predFn, FunctionType([this.value_type, this.key_type], BooleanType, null));
+        return this.groupReduce(((_$, value, key) => Expr.fromAst(keyFnAst)(value, key)), (() => true), ((_$, acc, value, key) => {
+            const pred = Expr.fromAst(predFnAst)(value, key);
+            return acc.and(() => pred);
+        }));
+    }
+    groupSome(keyFn, predFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const predFnAst = valueOrExprToAstTyped(predFn, FunctionType([this.value_type, this.key_type], BooleanType, null));
+        return this.groupReduce(((_$, value, key) => Expr.fromAst(keyFnAst)(value, key)), (() => false), ((_$, acc, value, key) => {
+            const pred = Expr.fromAst(predFnAst)(value, key);
+            return acc.or(() => pred);
+        }));
+    }
+    groupSum(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, v) => v), FunctionType([this.value_type, 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(((_$, value, key) => Expr.fromAst(keyFnAst)(value, key)), ((_$, value, key) => Expr.fromAst(valueFnAst)(value, key)), ((_$, a, b) => a.add(b)));
+    }
+    groupMean(keyFn, valueFn) {
+        const keyFnAst = valueOrExprToAstTyped(keyFn, FunctionType([this.value_type, this.key_type], undefined, null));
+        const valueFnAst = valueOrExprToAstTyped(valueFn ?? ((_$, v) => v), FunctionType([this.value_type, 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(((_$, value, key) => Expr.fromAst(keyFnAst)(value, key)), ((_$, value, key) => {
+            const val = Expr.fromAst(valueFnAst)(value, 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())));
+    }
+    /**
+     * Reduces the dictionary to a single value using an accumulator function.
+     *
+     * @param fn - Function accepting (accumulator, value, key) 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 values before combining
+     * @see {@link sum} and {@link mean} for common numeric reductions
+     *
+     * @example
+     * ```ts
+     * const sumValues = East.function([DictType(StringType, IntegerType)], IntegerType, ($, dict) => {
+     *   $.return(dict.reduce(($, acc, value, key) => acc.add(value), 0n));
+     * });
+     * const compiled = East.compile(sumValues.toIR(), []);
+     * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
+     * compiled(dict);  // 6n
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Concatenate keys
+     * const concatKeys = East.function([DictType(StringType, IntegerType)], StringType, ($, dict) => {
+     *   $.return(dict.reduce(($, acc, value, key) => acc.concat(",").concat(key), ""));
+     * });
+     * const compiled = East.compile(concatKeys.toIR(), []);
+     * compiled(dict);  // ",a,b,c"
+     * ```
+     */
+    reduce(fn, init) {
+        const initAst = valueOrExprToAst(init);
+        const returnType = initAst.type;
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([returnType, this.value_type, this.key_type], returnType, null));
+        return this[FactorySymbol]({
+            ast_type: "Builtin",
+            type: returnType,
+            location: get_location(2),
+            builtin: "DictReduce",
+            type_parameters: [this.key_type, this.value_type, returnType],
+            arguments: [this[AstSymbol], fnAst, initAst],
+        });
+    }
+    mapReduce(mapFn, combineFn) {
+        const mapAst = valueOrExprToAstTyped(mapFn, FunctionType([this.value_type, this.key_type], 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: "DictMapReduce",
+            type_parameters: [this.key_type, this.value_type, mapType],
+            arguments: [this[AstSymbol], mapAst, combineAst],
+        });
+    }
+    firstMap(fn) {
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, 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: "DictFirstMap",
+            type_parameters: [this.key_type, this.value_type, someType],
+            arguments: [this[AstSymbol], fnAst],
+        });
+    }
+    // Common reducers are provided, based on reduce
+    /**
+     * Returns true if every value in the dictionary is true, or false otherwise.
+     *
+     * This method short-circuits on the first false value. Note that empty dictionaries always return true.
+     * For dictionaries whose values are not Boolean, a mapping function must be provided.
+     *
+     * @param fn - Optional function to map each (value, key) pair to a boolean
+     * @returns A BooleanExpr that is true if all values satisfy the condition
+     *
+     * @see {@link some} to check if at least one element is true
+     * @see {@link groupEvery} to check every element within groups
+     *
+     * @example
+     * ```ts
+     * const allPositive = East.function([DictType(StringType, IntegerType)], BooleanType, ($, dict) => {
+     *   $.return(dict.every(($, value, key) => value.greater(0n)));
+     * });
+     * const compiled = East.compile(allPositive.toIR(), []);
+     * const dict1 = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
+     * compiled(dict1);  // true
+     * const dict2 = new Map([["a", 1n], ["b", -2n], ["c", 3n]]);
+     * compiled(dict2);  // false (short-circuits at "b")
+     * compiled(new Map());  // true (empty dictionary)
+     * ```
+     */
+    every(fn) {
+        if (fn === undefined) {
+            if (!isTypeEqual(this.value_type, BooleanType)) {
+                throw new Error(`Can only perform every on dict of booleans, got ${printType(this.value_type)}`);
+            }
+            // Short-circuit on first false value - use explicit function AST to avoid type inference issues
+            const optionType = VariantType({ none: NullType, some: NullType });
+            const valueParam = {
+                ast_type: "Variable",
+                type: this.value_type,
+                location: get_location(2),
+                mutable: false,
+            };
+            const keyParam = {
+                ast_type: "Variable",
+                type: this.key_type,
+                location: get_location(2),
+                mutable: false,
+            };
+            // Check if boolean value 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: [valueParam]
+            };
+            const checkFnAst = {
+                ast_type: "Function",
+                type: FunctionType([this.value_type, this.key_type], optionType, []),
+                location: get_location(2),
+                parameters: [valueParam, keyParam],
+                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: "DictFirstMap",
+                type_parameters: [this.key_type, this.value_type, NullType],
+                arguments: [this[AstSymbol], checkFnAst],
+            });
+            return Expr.match(result, { some: () => false, none: () => true });
+        }
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, this.key_type], BooleanType, null));
+        // Short-circuit on first false value
+        const result = this.firstMap(($, value, key) => {
+            const result = Expr.fromAst(fnAst)(value, key);
+            return result.not().ifElse(() => some(null), () => none);
+        });
+        return Expr.match(result, { some: () => false, none: () => true });
+    }
+    /**
+     * Returns true if at least one value in the dictionary is true, or false otherwise.
+     *
+     * This method short-circuits on the first true value. Note that empty dictionaries always return false.
+     * For dictionaries whose values are not Boolean, a mapping function must be provided.
+     *
+     * @param fn - Optional function to map each (value, key) pair to a boolean
+     * @returns A BooleanExpr that is true if any value satisfies the condition
+     *
+     * @see {@link every} to check if all elements are true
+     * @see {@link groupSome} to check if some element exists within groups
+     *
+     * @example
+     * ```ts
+     * const hasNegative = East.function([DictType(StringType, IntegerType)], BooleanType, ($, dict) => {
+     *   $.return(dict.some(($, value, key) => value.less(0n)));
+     * });
+     * const compiled = East.compile(hasNegative.toIR(), []);
+     * const dict1 = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
+     * compiled(dict1);  // false
+     * const dict2 = new Map([["a", 1n], ["b", -2n], ["c", 3n]]);
+     * compiled(dict2);  // true (short-circuits at "b")
+     * compiled(new Map());  // false (empty dictionary)
+     * ```
+     */
+    some(fn) {
+        if (fn === undefined) {
+            if (!isTypeEqual(this.value_type, BooleanType)) {
+                throw new Error(`Can only perform some on dict of booleans, got ${printType(this.value_type)}`);
+            }
+            // Short-circuit on first true value - use explicit function AST to avoid type inference issues
+            const optionType = VariantType({ none: NullType, some: NullType });
+            const valueParam = {
+                ast_type: "Variable",
+                type: this.value_type,
+                location: get_location(2),
+                mutable: false,
+            };
+            const keyParam = {
+                ast_type: "Variable",
+                type: this.key_type,
+                location: get_location(2),
+                mutable: false,
+            };
+            // Check if boolean value is true, then return some(null) to stop, otherwise return none to continue
+            const checkFnAst = {
+                ast_type: "Function",
+                type: FunctionType([this.value_type, this.key_type], optionType, []),
+                location: get_location(2),
+                parameters: [valueParam, keyParam],
+                body: {
+                    ast_type: "IfElse",
+                    type: optionType,
+                    location: get_location(2),
+                    ifs: [{
+                            predicate: valueParam,
+                            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: "DictFirstMap",
+                type_parameters: [this.key_type, this.value_type, NullType],
+                arguments: [this[AstSymbol], checkFnAst],
+            });
+            return Expr.match(result, { some: () => true, none: () => false });
+        }
+        const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, this.key_type], BooleanType, null));
+        // Short-circuit on first true value
+        const result = this.firstMap(($, value, key) => {
+            const result = Expr.fromAst(fnAst)(value, key);
+            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 dict 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, 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 dict 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 mean on dict of numbers (Integer or Float), got ${printType(this.value_type)}`);
+            }
+        }
+        else {
+            const fnAst = valueOrExprToAstTyped(fn, FunctionType([this.value_type, this.key_type], 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 mean on dict of numbers (Integer or Float), got ${printType(returnType)}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=dict.js.map