@elaraai/east 1.0.80 → 1.0.81

package/dist/src/expr/dict.d.ts

@@ -3,7 +3,7 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 import type { AST } from "../ast.js";
-import { DictType, BooleanType, FunctionType, IntegerType, NullType, OptionType, SetType, NeverType, VariantType, FloatType, ArrayType } from "../types.js";
+import { DictType, BooleanType, FunctionType, IntegerType, type EastType, NullType, OptionType, SetType, NeverType, VariantType, FloatType, ArrayType } from "../types.js";
 import type { BooleanExpr } from "./boolean.js";
 import type { IntegerExpr } from "./integer.js";
 import { Expr, type ToExpr } from "./expr.js";
@@ -29,7 +29,7 @@ import type { ArrayExpr } from "./array.js";
  *   $(counts.merge(word, 1n, ($, existing, increment) => existing.add(increment), () => 0n));
  *   $.return(null);
  * });
- * const compiled = East.compile(updateCounts.toIR(), []);
+ * const compiled = East.compile(updateCounts, []);
  * const counts = new Map([["hello", 5n], ["world", 3n]]);
  * compiled(counts, "hello");  // counts is now Map([["hello", 6n], ["world", 3n]])
  * compiled(counts, "new");    // counts is now Map([["hello", 6n], ["new", 1n], ["world", 3n]])
@@ -43,7 +43,7 @@ import type { ArrayExpr } from "./array.js";
  * const combine = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, a, b) => {
  *   $.return(a.union(b, ($, existing, incoming) => existing.add(incoming)));
  * });
- * const compiled = East.compile(combine.toIR(), []);
+ * const compiled = East.compile(combine, []);
  * compiled(new Map([["a", 1n], ["b", 2n]]), new Map([["b", 3n], ["c", 4n]]));
  * // Map([["a", 1n], ["b", 5n], ["c", 4n]]) — both inputs unchanged
  * ```
@@ -54,7 +54,7 @@ import type { ArrayExpr } from "./array.js";
  * const filterHighScores = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, scores) => {
  *   $.return(scores.filter(($, score, name) => score.greaterEqual(100n)));
  * });
- * const compiled = East.compile(filterHighScores.toIR(), []);
+ * const compiled = East.compile(filterHighScores, []);
  * const scores = new Map([["alice", 150n], ["bob", 75n], ["charlie", 200n]]);
  * compiled(scores);  // Map([["alice", 150n], ["charlie", 200n]])
  * ```
@@ -73,7 +73,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const getSize = East.function([DictType(StringType, IntegerType)], IntegerType, ($, dict) => {
      *   $.return(dict.size());
      * });
-     * const compiled = East.compile(getSize.toIR(), []);
+     * const compiled = East.compile(getSize, []);
      * compiled(new Map([["a", 1n], ["b", 2n], ["c", 3n]]));  // 3n
      * compiled(new Map());  // 0n
      * ```
@@ -90,7 +90,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const hasKey = East.function([DictType(StringType, IntegerType), StringType], BooleanType, ($, dict, key) => {
      *   $.return(dict.has(key));
      * });
-     * const compiled = East.compile(hasKey.toIR(), []);
+     * const compiled = East.compile(hasKey, []);
      * const dict = new Map([["a", 1n], ["b", 2n]]);
      * compiled(dict, "a");     // true
      * compiled(dict, "c");     // false
@@ -114,7 +114,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const getValue = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
      *   $.return(dict.get(key));
      * });
-     * const compiled = East.compile(getValue.toIR(), []);
+     * const compiled = East.compile(getValue, []);
      * const dict = new Map([["a", 1n], ["b", 2n]]);
      * compiled(dict, "a");  // 1n
      * // compiled(dict, "c") would throw error
@@ -126,7 +126,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const getWithDefault = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
      *   $.return(dict.get(key, () => -1n));
      * });
-     * const compiled = East.compile(getWithDefault.toIR(), []);
+     * const compiled = East.compile(getWithDefault, []);
      * compiled(dict, "a");  // 1n
      * compiled(dict, "c");  // -1n
      * ```
@@ -145,7 +145,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const tryGetValue = East.function([DictType(StringType, IntegerType), StringType], OptionType(IntegerType), ($, dict, key) => {
      *   $.return(dict.tryGet(key));
      * });
-     * const compiled = East.compile(tryGetValue.toIR(), []);
+     * const compiled = East.compile(tryGetValue, []);
      * const dict = new Map([["a", 1n], ["b", 2n]]);
      * compiled(dict, "a");  // { tag: "some", value: 1n }
      * compiled(dict, "c");  // { tag: "none", value: null }
@@ -160,7 +160,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *     none: () => 0n
      *   }));
      * });
-     * const compiled = East.compile(getOrDefault.toIR(), []);
+     * const compiled = East.compile(getOrDefault, []);
      * compiled(dict, "a");  // 1n
      * compiled(dict, "c");  // 0n
      * ```
@@ -185,7 +185,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict.insert(key, value));
      *   $.return(null);
      * });
-     * const compiled = East.compile(insertEntry.toIR(), []);
+     * const compiled = East.compile(insertEntry, []);
      * 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)
@@ -213,7 +213,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict.insertOrUpdate(key, value));
      *   $.return(null);
      * });
-     * const compiled = East.compile(upsert.toIR(), []);
+     * const compiled = East.compile(upsert, []);
      * 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]])
@@ -239,7 +239,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict.update(key, newValue));
      *   $.return(null);
      * });
-     * const compiled = East.compile(updateValue.toIR(), []);
+     * const compiled = East.compile(updateValue, []);
      * 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)
@@ -279,7 +279,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(counts.merge(word, 1n, ($, existing, inc) => existing.add(inc), () => 0n));
      *   $.return(null);
      * });
-     * const compiled = East.compile(increment.toIR(), []);
+     * const compiled = East.compile(increment, []);
      * 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]])
@@ -292,7 +292,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict.merge(key, suffix, ($, existing, newVal) => existing.concat(newVal), () => ""));
      *   $.return(null);
      * });
-     * const compiled = East.compile(appendText.toIR(), []);
+     * const compiled = East.compile(appendText, []);
      * const dict = new Map([["greeting", "Hello"]]);
      * compiled(dict, "greeting", " World");  // Map([["greeting", "Hello World"]])
      * compiled(dict, "new", "Hi");           // Map([["greeting", "Hello World"], ["new", "Hi"]])
@@ -317,7 +317,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const getOrCreate = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
      *   $.return(dict.getOrInsert(key, () => 0n));
      * });
-     * const compiled = East.compile(getOrCreate.toIR(), []);
+     * const compiled = East.compile(getOrCreate, []);
      * const dict = new Map([["a", 1n]]);
      * compiled(dict, "a");  // 1n (existing value)
      * compiled(dict, "b");  // 0n (new value inserted)
@@ -343,7 +343,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict.delete(key));
      *   $.return(null);
      * });
-     * const compiled = East.compile(deleteKey.toIR(), []);
+     * const compiled = East.compile(deleteKey, []);
      * 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)
@@ -364,7 +364,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const tryDeleteKey = East.function([DictType(StringType, IntegerType), StringType], BooleanType, ($, dict, key) => {
      *   $.return(dict.tryDelete(key));
      * });
-     * const compiled = East.compile(tryDeleteKey.toIR(), []);
+     * const compiled = East.compile(tryDeleteKey, []);
      * 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)
@@ -387,7 +387,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const popKey = East.function([DictType(StringType, IntegerType), StringType], IntegerType, ($, dict, key) => {
      *   $.return(dict.pop(key));
      * });
-     * const compiled = East.compile(popKey.toIR(), []);
+     * const compiled = East.compile(popKey, []);
      * 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)
@@ -411,7 +411,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * 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 compiled = East.compile(swapValue, []);
      * 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)
@@ -431,7 +431,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict.clear());
      *   $.return(null);
      * });
-     * const compiled = East.compile(clearDict.toIR(), []);
+     * const compiled = East.compile(clearDict, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict);  // dict is now Map([])
      * ```
@@ -457,7 +457,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   $(dict1.unionInPlace(dict2, ($, existing, newVal) => existing.add(newVal)));
      *   $.return(null);
      * });
-     * const compiled = East.compile(unionDicts.toIR(), []);
+     * const compiled = East.compile(unionDicts, []);
      * 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]])
@@ -493,7 +493,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const combine = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict1, dict2) => {
      *   $.return(dict1.union(dict2, ($, existing, newVal) => existing.add(newVal)));
      * });
-     * const compiled = East.compile(combine.toIR(), []);
+     * const compiled = East.compile(combine, []);
      * const dict1 = new Map([["a", 1n], ["b", 2n]]);
      * const dict2 = new Map([["b", 3n], ["c", 4n]]);
      * compiled(dict1, dict2);  // Map([["a", 1n], ["b", 5n], ["c", 4n]]) — dict1 is unchanged
@@ -528,7 +528,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *     $.return(null);
      *   }
      * );
-     * const compiled = East.compile(mergeCounts.toIR(), []);
+     * const compiled = East.compile(mergeCounts, []);
      * 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]])
@@ -547,7 +547,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const getKeys = East.function([DictType(StringType, IntegerType)], SetType(StringType), ($, dict) => {
      *   $.return(dict.keys());
      * });
-     * const compiled = East.compile(getKeys.toIR(), []);
+     * const compiled = East.compile(getKeys, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict);  // Set(["a", "b", "c"])
      * ```
@@ -569,7 +569,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * 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 compiled = East.compile(selectKeys, []);
      * 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]])
@@ -581,7 +581,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * 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 compiled = East.compile(selectWithDefault, []);
      * const keysWithMissing = new Set(["a", "x"]);
      * compiled(dict, keysWithMissing);  // Map([["a", 1n], ["x", 0n]])
      * ```
@@ -602,7 +602,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *   }));
      *   $.return(null);
      * });
-     * const compiled = East.compile(printEntries.toIR(), []);
+     * const compiled = East.compile(printEntries, []);
      * const dict = new Map([["a", 1n], ["b", 2n]]);
      * compiled(dict);  // Iterates over all entries
      * ```
@@ -618,7 +618,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const copyDict = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict) => {
      *   $.return(dict.copy());
      * });
-     * const compiled = East.compile(copyDict.toIR(), []);
+     * const compiled = East.compile(copyDict, []);
      * const dict = new Map([["a", 1n], ["b", 2n]]);
      * const copy = compiled(dict);  // Map([["a", 1n], ["b", 2n]])
      * // Modifying copy doesn't affect dict
@@ -641,7 +641,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const doubleValues = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict) => {
      *   $.return(dict.map(($, value, key) => value.multiply(2n)));
      * });
-     * const compiled = East.compile(doubleValues.toIR(), []);
+     * const compiled = East.compile(doubleValues, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict);  // Map([["a", 2n], ["b", 4n], ["c", 6n]])
      * ```
@@ -662,7 +662,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const filterLargeValues = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict) => {
      *   $.return(dict.filter(($, value, key) => value.greaterEqual(10n)));
      * });
-     * const compiled = East.compile(filterLargeValues.toIR(), []);
+     * const compiled = East.compile(filterLargeValues, []);
      * const dict = new Map([["a", 5n], ["b", 15n], ["c", 20n], ["d", 8n]]);
      * compiled(dict);  // Map([["b", 15n], ["c", 20n]])
      * ```
@@ -692,7 +692,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *     )
      *   ));
      * });
-     * const compiled = East.compile(filterMapEven.toIR(), []);
+     * const compiled = East.compile(filterMapEven, []);
      * const dict = new Map([["a", 2n], ["b", 3n], ["c", 4n], ["d", 5n]]);
      * compiled(dict);  // Map([["a", 1n], ["c", 2n]]) - only even values, halved
      * ```
@@ -715,7 +715,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const dictToArray = East.function([DictType(StringType, IntegerType)], ArrayType(IntegerType), ($, dict) => {
      *   $.return(dict.toArray());  // Just values
      * });
-     * const compiled = East.compile(dictToArray.toIR(), []);
+     * const compiled = East.compile(dictToArray, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict);  // [1n, 2n, 3n]
      * ```
@@ -726,7 +726,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const pairsToArray = East.function([DictType(StringType, IntegerType)], ArrayType(StringType), ($, dict) => {
      *   $.return(dict.toArray(($, value, key) => Expr.str`${key}: ${value}`));
      * });
-     * const compiled = East.compile(pairsToArray.toIR(), []);
+     * const compiled = East.compile(pairsToArray, []);
      * compiled(dict);  // ["a: 1", "b: 2", "c: 3"]
      * ```
      */
@@ -749,7 +749,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const extractCategories = East.function([DictType(StringType, StructType({category: StringType, price: IntegerType}))], SetType(StringType), ($, products) => {
      *   $.return(products.toSet(($, product, name) => product.category));
      * });
-     * const compiled = East.compile(extractCategories.toIR(), []);
+     * const compiled = East.compile(extractCategories, []);
      * const products = new Map([
      *   ["apple", {category: "fruit", price: 100n}],
      *   ["banana", {category: "fruit", price: 80n}],
@@ -784,7 +784,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const uppercaseKeys = East.function([DictType(StringType, IntegerType)], DictType(StringType, IntegerType), ($, dict) => {
      *   $.return(dict.toDict(($, value, key) => key.upperCase()));
      * });
-     * const compiled = East.compile(uppercaseKeys.toIR(), []);
+     * const compiled = East.compile(uppercaseKeys, []);
      * const dict = new Map([["a", 1n], ["b", 2n]]);
      * compiled(dict);  // Map([["A", 1n], ["B", 2n]])
      * ```
@@ -799,7 +799,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *     ($, existing, newVal, len) => existing.add(newVal)
      *   ));
      * });
-     * const compiled = East.compile(groupByLength.toIR(), []);
+     * const compiled = East.compile(groupByLength, []);
      * const dict2 = new Map([["a", 1n], ["ab", 2n], ["c", 3n], ["def", 4n]]);
      * compiled(dict2);  // Map([[1n, 4n], [2n, 2n], [3n, 4n]])
      * ```
@@ -834,7 +834,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      *     return arr;
      *   }));
      * });
-     * const compiled = East.compile(expandRanges.toIR(), []);
+     * const compiled = East.compile(expandRanges, []);
      * const dict = new Map([["a", 2n], ["b", 3n]]);
      * compiled(dict);  // [0n, 1n, 0n, 1n, 2n] - flattened ranges
      * ```
@@ -860,7 +860,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const getAllTags = East.function([DictType(StringType, ArrayType(StringType))], SetType(StringType), ($, articles) => {
      *   $.return(articles.flattenToSet(($, tags, title) => tags.toSet()));
      * });
-     * const compiled = East.compile(getAllTags.toIR(), []);
+     * const compiled = East.compile(getAllTags, []);
      * const articles = new Map([
      *   ["Article 1", ["javascript", "programming"]],
      *   ["Article 2", ["python", "programming"]],
@@ -894,7 +894,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const mergeNestedDicts = East.function([DictType(StringType, DictType(StringType, IntegerType))], DictType(StringType, IntegerType), ($, nested) => {
      *   $.return(nested.flattenToDict(undefined, ($, existing, newVal) => existing.add(newVal)));
      * });
-     * const compiled = East.compile(mergeNestedDicts.toIR(), []);
+     * const compiled = East.compile(mergeNestedDicts, []);
      * const nested = new Map([
      *   ["group1", new Map([["a", 1n], ["b", 2n]])],
      *   ["group2", new Map([["b", 3n], ["c", 4n]])]
@@ -905,6 +905,56 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
     flattenToDict<K2, V2>(fn: Expr<FunctionType<[K], DictType<K2, V2>>>, onConflict?: SubtypeExprOrValue<FunctionType<[NoInfer<V2>, NoInfer<V2>, NoInfer<K2>], NoInfer<V2>>>): DictExpr<K2, V2>;
     flattenToDict<F extends (($: BlockBuilder<NeverType>, v: ExprType<T>, k: ExprType<K>) => any)>(fn: F, onConflict?: SubtypeExprOrValue<FunctionType<[TypeOf<ReturnType<NoInfer<F>>> extends DictType<any, infer V2> ? V2 : never, TypeOf<ReturnType<NoInfer<F>>> extends DictType<any, infer V2> ? V2 : never, TypeOf<ReturnType<NoInfer<F>>> extends DictType<infer K2, any> ? K2 : never], TypeOf<ReturnType<NoInfer<F>>> extends DictType<any, infer V2> ? V2 : never>>): TypeOf<ReturnType<F>> extends DictType<infer K2, infer V2> ? DictExpr<K2, V2> : never;
     flattenToDict(): T extends DictType<infer K2, infer V2> ? DictExpr<K2, V2> : never;
+    /**
+     * Builds a tree of any depth from the dictionary's entries, in a node type of your own; each entry's key is its key.
+     *
+     * `parentFn` names each entry's parent key; `buildFn` turns an entry and its children's built nodes into its
+     * node. The result is the roots.
+     *
+     * @param node - The node type `buildFn` returns; its `children` argument is an Array of it
+     * @param parentFn - Function taking (value, key) and returning the parent's key, or `none` for a root
+     * @param buildFn - Function taking (value, key, children) and returning the entry's node
+     * @returns An ArrayExpr of the root nodes, in key order
+     *
+     * @throws East runtime error if the parents form a cycle, naming the first key in key order on the cycle
+     *
+     * @remarks
+     * - An entry whose parent key is not in the dictionary (an orphan) becomes a root.
+     * - `buildFn` runs once per entry, children before parents; `children` holds the built children in key
+     *   order. Every `parentFn` runs first, and the cycle check comes before any `buildFn`.
+     * - `node` can be any type: a recursive node type builds a tree value, a non-recursive one folds bottom-up.
+     * - The walk is iterative, so building costs no stack at any depth. A recursive node value is still limited
+     *   in depth on the C and Python runtimes, which collect and free a value recursively: tens of thousands of
+     *   levels.
+     *
+     * @example
+     * ```ts
+     * const EntryType = StructType({ name: StringType, parent: OptionType(StringType) });
+     * const NodeType = RecursiveType(self => StructType({ id: StringType, name: StringType, children: ArrayType(self) }));
+     *
+     * const nest = East.function([DictType(StringType, EntryType)], ArrayType(NodeType), ($, entries) => {
+     *   $.return(entries.toTree(
+     *     NodeType,
+     *     ($, entry, id) => entry.parent,
+     *     ($, entry, id, children) => ({ id, name: entry.name, children }),
+     *   ));
+     * });
+     * const compiled = East.compile(nest, []);
+     * compiled(new Map([
+     *   ["animals", { name: "Animals", parent: none }],
+     *   ["birds", { name: "Birds", parent: some("animals") }],
+     *   ["mammals", { name: "Mammals", parent: some("animals") }],
+     *   ["whales", { name: "Whales", parent: some("mammals") }],
+     * ]));
+     * // [{ id: "animals", name: "Animals", children: [
+     * //   { id: "birds", name: "Birds", children: [] },
+     * //   { id: "mammals", name: "Mammals", children: [{ id: "whales", name: "Whales", children: [] }] },
+     * // ] }]
+     * ```
+     *
+     * @see {@link ArrayExpr.toTree} for elements that carry their own key.
+     */
+    toTree<N extends EastType>(node: N, parentFn: SubtypeExprOrValue<FunctionType<[T, K], OptionType<K>>>, buildFn: SubtypeExprOrValue<FunctionType<[T, K, ArrayType<NoInfer<N>>], NoInfer<N>>>): ArrayExpr<N>;
     /** Group entries by key and perform a fold/reduce operation on each group.
      *
      * @param keyFn - Function that maps each value and key to a group key
@@ -1122,7 +1172,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * 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 compiled = East.compile(sumValues, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict);  // 6n
      * ```
@@ -1133,7 +1183,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * 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(), []);
+     * const compiled = East.compile(concatKeys, []);
      * compiled(dict);  // ",a,b,c"
      * ```
      */
@@ -1156,7 +1206,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const runningTotal = East.function([DictType(StringType, IntegerType)], ArrayType(IntegerType), ($, dict) => {
      *   $.return(dict.scan(($, acc, value, key) => acc.add(value), 0n));
      * });
-     * const compiled = East.compile(runningTotal.toIR(), []);
+     * const compiled = East.compile(runningTotal, []);
      * compiled(new Map([["a", 1n], ["b", 2n], ["c", 3n]]));  // [1n, 3n, 6n]
      * compiled(new Map());                                    // []
      * ```
@@ -1240,7 +1290,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const allPositive = East.function([DictType(StringType, IntegerType)], BooleanType, ($, dict) => {
      *   $.return(dict.every(($, value, key) => value.greater(0n)));
      * });
-     * const compiled = East.compile(allPositive.toIR(), []);
+     * const compiled = East.compile(allPositive, []);
      * const dict1 = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict1);  // true
      * const dict2 = new Map([["a", 1n], ["b", -2n], ["c", 3n]]);
@@ -1266,7 +1316,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const hasNegative = East.function([DictType(StringType, IntegerType)], BooleanType, ($, dict) => {
      *   $.return(dict.some(($, value, key) => value.less(0n)));
      * });
-     * const compiled = East.compile(hasNegative.toIR(), []);
+     * const compiled = East.compile(hasNegative, []);
      * const dict1 = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict1);  // false
      * const dict2 = new Map([["a", 1n], ["b", -2n], ["c", 3n]]);
@@ -1292,7 +1342,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const sumValues = East.function([DictType(StringType, IntegerType)], IntegerType, ($, dict) => {
      *   $.return(dict.sum());
      * });
-     * const compiled = East.compile(sumValues.toIR(), []);
+     * const compiled = East.compile(sumValues, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n]]);
      * compiled(dict);  // 6n
      * ```
@@ -1303,7 +1353,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const sumLengths = East.function([DictType(StringType, StringType)], IntegerType, ($, dict) => {
      *   $.return(dict.sum(($, value, key) => value.length()));
      * });
-     * const compiled = East.compile(sumLengths.toIR(), []);
+     * const compiled = East.compile(sumLengths, []);
      * const dict2 = new Map([["a", "hello"], ["b", "world"]]);
      * compiled(dict2);  // 10n (5 + 5)
      * ```
@@ -1329,7 +1379,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const avgValue = East.function([DictType(StringType, IntegerType)], FloatType, ($, dict) => {
      *   $.return(dict.mean());
      * });
-     * const compiled = East.compile(avgValue.toIR(), []);
+     * const compiled = East.compile(avgValue, []);
      * const dict = new Map([["a", 1n], ["b", 2n], ["c", 3n], ["d", 4n]]);
      * compiled(dict);  // 2.5
      * ```
@@ -1340,7 +1390,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const avgLength = East.function([DictType(StringType, StringType)], FloatType, ($, dict) => {
      *   $.return(dict.mean(($, value, key) => value.length()));
      * });
-     * const compiled = East.compile(avgLength.toIR(), []);
+     * const compiled = East.compile(avgLength, []);
      * const dict2 = new Map([["a", "hi"], ["b", "hello"], ["c", "hey"]]);
      * compiled(dict2);  // 3.3333333333333335 (average of 2, 5, 3)
      * ```
@@ -1360,7 +1410,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const isEqual = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], BooleanType, ($, a, b) => {
      *   $.return(a.equals(b));
      * });
-     * const compiled = East.compile(isEqual.toIR(), []);
+     * const compiled = East.compile(isEqual, []);
      * compiled(new Map([["a", 1n], ["b", 2n]]), new Map([["a", 1n], ["b", 2n]]));  // true
      * compiled(new Map([["a", 1n]]), new Map([["a", 1n], ["b", 2n]]));            // false
      * ```
@@ -1377,7 +1427,7 @@ export declare class DictExpr<K extends any, T extends any> extends Expr<DictTyp
      * const isNotEqual = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], BooleanType, ($, a, b) => {
      *   $.return(a.notEquals(b));
      * });
-     * const compiled = East.compile(isNotEqual.toIR(), []);
+     * const compiled = East.compile(isNotEqual, []);
      * compiled(new Map([["a", 1n]]), new Map([["a", 1n], ["b", 2n]]));            // true
      * compiled(new Map([["a", 1n], ["b", 2n]]), new Map([["a", 1n], ["b", 2n]]));  // false
      * ```