@harmoniclabs/pebble 0.1.10 → 0.3.0

package/dist/IR/toUPLC/subRoutines/introduceCaseForDualHeadTailAndReturnRoot.js

@@ -0,0 +1,169 @@
+/**
+ * When the same list `L` is used for BOTH `headList(L)` and `tailList(L)`
+ * within a single function body, those two builtin calls can be replaced
+ * by a single `case L of cons h t -> body[h/headList(L), t/tailList(L)] |
+ * nil -> error`. The trade-off (measured in `bench.headTailVsCase`):
+ *
+ *   - one `headList` (or `tailList`) builtin call: 112,100 CPU / 800 mem
+ *   - one `case L of cons h t -> h | nil -> error`: 128,100 CPU / 900 mem
+ *
+ * So for a single access the builtin wins; for dual access the case wins
+ * by a single dispatch (~96K CPU / 700 mem).
+ *
+ * This pass walks every `IRFunc` body bottom-up. For each body, it scans
+ * the top-level (without descending into nested `IRFunc`/`IRRecursive`,
+ * because nested scopes are processed independently). If a free list var
+ * `L` has both a `headList(L)` and a `tailList(L)` use in the body, the
+ * body is wrapped with `IRCase(IRVar(L), [IRFunc([h, t], body'), IRError])`
+ * — where `body'` has those calls replaced with `IRVar(h)` / `IRVar(t)`.
+ *
+ * Notes:
+ *   - We only act on `IRFunc` bodies that are NOT immediate continuations
+ *     of an `IRCase` whose scrutinee is `IRVar(L)` for the same L — that
+ *     case-cons branch already binds head/tail and the prior
+ *     `rewriteHeadTailInCaseConsAndReturnRoot` pass has already done the
+ *     substitution. Wrapping again would be a no-op constructor pair.
+ *   - The nil branch is `IRError`. Original code that calls `headList` or
+ *     `tailList` on a nil list errors at evaluation; the new code errors
+ *     at the case dispatch — same observable behavior whenever either
+ *     call is actually reached.
+ *   - The pass iterates: after introducing a case for L, the (now
+ *     substituted) body might still contain a different L' with dual
+ *     head/tail uses — handled by re-scanning until no more pairs.
+ */
+import { IRApp } from "../../IRNodes/IRApp.js";
+import { IRCase } from "../../IRNodes/IRCase.js";
+import { IRError } from "../../IRNodes/IRError.js";
+import { IRFunc } from "../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { IRNative } from "../../IRNodes/IRNative/index.js";
+import { IRNativeTag } from "../../IRNodes/IRNative/IRNativeTag.js";
+import { IRRecursive } from "../../IRNodes/IRRecursive.js";
+import { IRVar } from "../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+function unwrap(t) {
+    while (t instanceof IRHoisted)
+        t = t.hoisted;
+    while (t instanceof IRLetted)
+        t = t.value;
+    return t;
+}
+export function introduceCaseForDualHeadTailAndReturnRoot(term) {
+    processNode(term);
+    return term;
+}
+function processNode(node) {
+    // Post-order: recurse into children first, then process this node.
+    for (const child of node.children())
+        processNode(child);
+    if (node instanceof IRFunc) {
+        // Avoid wrapping case-cons branches that the previous pass already
+        // optimized: if `node` is the cons continuation of an outer
+        // `IRCase(IRVar(L), [node, ...])`, then head(L)/tail(L) were
+        // already substituted; if any dual remains it's for a *different*
+        // list L', which we handle normally.
+        tryWrap(node);
+    }
+}
+function tryWrap(fn) {
+    while (true) {
+        const choice = findFirstDualHeadTailList(fn.body, new Set(fn.params));
+        if (choice === undefined)
+            return;
+        const listSym = choice;
+        const desc = listSym.description ?? "L";
+        const hSym = Symbol("h_" + desc);
+        const tSym = Symbol("t_" + desc);
+        // Substitute head(L)/tail(L) inside the current body (won't descend
+        // into nested scopes that re-bind L, h, or t — but we just minted
+        // h/t so they don't collide with anything).
+        substituteHeadTailInBody(fn.body, listSym, hSym, tSym);
+        // Wrap.
+        const oldBody = fn.body;
+        const consFn = new IRFunc([hSym, tSym], oldBody);
+        const wrapped = new IRCase(new IRVar(listSym), [consFn, new IRError()]);
+        fn.body = wrapped;
+    }
+}
+/**
+ * Scan `root` for free `headList(L)`/`tailList(L)` uses where `L` is NOT
+ * shadowed by an enclosing nested IRFunc/IRRecursive within `root`. Returns
+ * the first list symbol with at least one head AND one tail use.
+ */
+function findFirstDualHeadTailList(root, boundInOuterFunc) {
+    const heads = new Set();
+    const tails = new Set();
+    function walk(node, locallyBound) {
+        if (node instanceof IRFunc) {
+            const next = new Set(locallyBound);
+            for (const p of node.params)
+                next.add(p);
+            walk(node.body, next);
+            return;
+        }
+        if (node instanceof IRRecursive) {
+            const next = new Set(locallyBound);
+            next.add(node.name);
+            walk(node.body, next);
+            return;
+        }
+        if (node instanceof IRApp) {
+            const fn = unwrap(node.fn);
+            const arg = node.arg;
+            if (fn instanceof IRNative
+                && arg instanceof IRVar
+                && !locallyBound.has(arg.name)
+                && (fn.tag === IRNativeTag.headList
+                    || fn.tag === IRNativeTag.tailList)) {
+                (fn.tag === IRNativeTag.headList ? heads : tails).add(arg.name);
+                // do not descend further — this is a leaf for our purposes
+                return;
+            }
+            // generic descent
+        }
+        for (const c of node.children())
+            walk(c, locallyBound);
+    }
+    walk(root, boundInOuterFunc);
+    for (const sym of heads) {
+        if (tails.has(sym))
+            return sym;
+    }
+    return undefined;
+}
+/**
+ * In-place: replace every `IRApp(unwrap=headList, IRVar(L))` /
+ * `IRApp(unwrap=tailList, IRVar(L))` inside `root` with `IRVar(h)` /
+ * `IRVar(t)`. Stops descending into any nested IRFunc/IRRecursive that
+ * shadows `L`, `h`, or `t`.
+ */
+function substituteHeadTailInBody(root, listSym, hSym, tSym) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRFunc || t instanceof IRRecursive) {
+            const params = t instanceof IRFunc ? t.params : [t.name];
+            if (params.includes(listSym)
+                || params.includes(hSym)
+                || params.includes(tSym))
+                continue;
+        }
+        if (t instanceof IRApp) {
+            const fn = unwrap(t.fn);
+            const arg = t.arg;
+            if (fn instanceof IRNative
+                && arg instanceof IRVar
+                && arg.name === listSym
+                && (fn.tag === IRNativeTag.headList || fn.tag === IRNativeTag.tailList)) {
+                const newSym = fn.tag === IRNativeTag.headList ? hSym : tSym;
+                const parent = t.parent;
+                if (parent !== undefined) {
+                    _modifyChildFromTo(parent, t, new IRVar(newSym));
+                }
+                continue;
+            }
+        }
+        stack.push(...t.children());
+    }
+}

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.d.ts

@@ -1,3 +1,2 @@
 import { IRTerm } from "../../IRTerm.js";
-export declare function __unsafe_clear_hoisted_cache(): void;
 export declare function replaceHoistedWithLetted(term: IRTerm): void;

package/dist/IR/toUPLC/subRoutines/replaceHoistedWithLetted.js

@@ -1,10 +1,7 @@
+import { currentCompilationCtx } from "../../CompilationCtx.js";
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
 import { IRLetted } from "../../IRNodes/IRLetted.js";
 import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-const _hoisted_cache = new Map();
-export function __unsafe_clear_hoisted_cache() {
-    _hoisted_cache.clear();
-}
 export function replaceHoistedWithLetted(term) {
     // children first
     const children = term.children();
@@ -16,11 +13,14 @@ export function replaceHoistedWithLetted(term) {
     const parent = term.parent;
     if (!parent)
         throw new Error("hoisted node has no parent");
-    const cached = _hoisted_cache.get(term.hash)?.deref();
+    // per-compilation cache: maps a hoisted term's content hash to the
+    // letted node it lowers to, so repeated occurrences share one binder.
+    const hoistedCache = currentCompilationCtx().hoistedCache;
+    const cached = hoistedCache.get(term.hash)?.deref();
     const letted = (cached ??
         new IRLetted(term.name, term.hoisted, { isClosed: true })).clone();
     if (!cached)
-        _hoisted_cache.set(term.hash, new WeakRef(letted));
+        hoistedCache.set(term.hash, new WeakRef(letted));
     // replace hoisted with letted
     _modifyChildFromTo(parent, term, letted);
 }

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -8,20 +8,19 @@ export declare const hoisted_decr: IRHoisted;
 export declare const hoisted_isZero: IRHoisted;
 export declare const hoisted_isOne: IRHoisted;
 export declare const hoisted_isTwo: IRHoisted;
+export declare const hoisted_negateValue: IRHoisted;
+export declare const hoisted_valueEq: IRHoisted;
 export declare const hoisted_isThree: IRHoisted;
 export declare const hoisted_addOne: IRHoisted;
 export declare const hoisted_subOne: IRHoisted;
 export declare const hoisted_negateInteger: IRHoisted;
 export declare const hoisted_isPositive: IRHoisted;
 export declare const hoisted_isNonNegative: IRHoisted;
-export declare const hoisted_matchList: IRHoisted;
 export declare const hoisted_recursiveList: IRHoisted;
 export declare const hoisted_foldr: IRHoisted;
-export declare const hosited_lazyChooseList: IRHoisted;
 export declare const hoisted_isMoreThanOrEqualTo4: IRHoisted;
 export declare const hoisted_sub4: IRHoisted;
 export declare const hoisted_length: IRHoisted;
-export declare const hoisted_dropList: IRHoisted;
 export declare const hoisted_findSopOptional: IRHoisted;
 export declare const hoisted_lookupLinearMap: IRHoisted;
 export declare const hoisted_mkFindDataOptional: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -13,10 +13,9 @@ import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
 import { IRError } from "../../../IRNodes/IRError.js";
 import { _ir_apps } from "../../../IRNodes/IRApp.js";
 import { _ir_let, _ir_let_sym } from "../../../tree_utils/_ir_let.js";
-import { _ir_lazyChooseList } from "../../../tree_utils/_ir_lazyChooseList.js";
+import { _ir_caseList } from "../../../tree_utils/_ir_caseList.js";
 import { _ir_lazyIfThenElse } from "../../../tree_utils/_ir_lazyIfThenElse.js";
-import { hoisted_drop4, hoisted_drop2, hoisted_drop3 } from "../_comptimeDropN.js";
-import { IRConstr } from "../../../IRNodes/index.js";
+import { IRCase, IRConstr } from "../../../IRNodes/index.js";
 import { _ir_and, _ir_or } from "../../../../compiler/tir/expressions/binary/TirBinaryExpr.js";
 function _ir_strictAnd(left, right) {
     return _ir_apps(IRNative.strictIfThenElse, left, right, IRConst.bool(false));
@@ -39,6 +38,22 @@ export const hoisted_isOne = new IRHoisted(new IRApp(IRNative.equalsInteger, IRC
 hoisted_isZero.hash;
 export const hoisted_isTwo = new IRHoisted(new IRApp(IRNative.equalsInteger, IRConst.int(2)));
 hoisted_isTwo.hash;
+// negateValue = (scaleValue -1)
+//   the scaleValue builtin is `(int, Value) -> Value`; partially applying
+//   -1 yields a unary `Value -> Value` negation. Cheaper than running a
+//   user-level multiply over the entire map.
+export const hoisted_negateValue = new IRHoisted(new IRApp(IRNative.scaleValue, IRConst.int(-1)));
+hoisted_negateValue.hash;
+// valueEq a b = if valueContains(a, b) then valueContains(b, a) else false
+//   Bidirectional containment is equality for canonical Values (the
+//   only form the runtime ever produces). Short-circuits on the first
+//   non-containment to save the second `valueContains` traversal.
+export const hoisted_valueEq = new IRHoisted((() => {
+    const a = Symbol("valueEq_a");
+    const b = Symbol("valueEq_b");
+    return new IRFunc([a, b], _ir_lazyIfThenElse(_ir_apps(IRNative.valueContains, new IRVar(a), new IRVar(b)), _ir_apps(IRNative.valueContains, new IRVar(b), new IRVar(a)), IRConst.bool(false)));
+})());
+hoisted_valueEq.hash;
 export const hoisted_isThree = new IRHoisted(new IRApp(IRNative.equalsInteger, IRConst.int(3)));
 export const hoisted_addOne = new IRHoisted(new IRApp(IRNative.addInteger, IRConst.int(1)));
 hoisted_addOne.hash;
@@ -50,22 +65,24 @@ export const hoisted_isPositive = new IRHoisted(new IRApp(IRNative.lessThanInteg
 hoisted_isPositive.hash;
 export const hoisted_isNonNegative = new IRHoisted(new IRApp(IRNative.lessThanEqualInteger, IRConst.int(0)));
 hoisted_isNonNegative.hash;
-export const hoisted_matchList = new IRHoisted((() => {
-    const delayed_matchNil = Symbol("delayed_matchNil");
-    const matchCons = Symbol("matchCons");
-    const list = Symbol("list");
-    return new IRFunc([delayed_matchNil, matchCons, list], new IRForced(new IRForced(_ir_apps(IRNative.strictChooseList, new IRVar(list), new IRVar(delayed_matchNil), new IRDelayed(_ir_apps(new IRVar(matchCons), new IRApp(IRNative.headList, new IRVar(list)), new IRApp(IRNative.tailList, new IRVar(list))))))));
-})());
-hoisted_matchList.hash;
-//*
 // hoisted_recursiveList (needed by hoisted_foldr)
+//   λ matchNil matchCons → recurse self → λ lst →
+//     case lst of
+//       cons h t -> (matchCons self) h t
+//       nil      -> force (matchNil self)
+// `matchNil` is expected to return a delayed value (so it can close over
+// recursive state without forcing eagerly); the nil branch forces it.
 const recList_matchNil = Symbol("matchNil");
 const recList_matchCons = Symbol("matchCons");
 const recList_self = Symbol("recursiveList_self");
 const recList_lst = Symbol("lst");
-export const hoisted_recursiveList = new IRHoisted(new IRFunc([recList_matchNil, recList_matchCons], new IRRecursive(recList_self, new IRFunc([recList_lst], _ir_apps(hoisted_matchList.clone(), new IRApp(new IRVar(recList_matchNil), new IRSelfCall(recList_self)), new IRApp(new IRVar(recList_matchCons), new IRSelfCall(recList_self)), new IRVar(recList_lst))))));
+const recList_h = Symbol("h");
+const recList_t = Symbol("t");
+export const hoisted_recursiveList = new IRHoisted(new IRFunc([recList_matchNil, recList_matchCons], new IRRecursive(recList_self, new IRFunc([recList_lst], new IRCase(new IRVar(recList_lst), [
+    new IRFunc([recList_h, recList_t], _ir_apps(new IRApp(new IRVar(recList_matchCons), new IRSelfCall(recList_self)), new IRVar(recList_h), new IRVar(recList_t))),
+    new IRForced(new IRApp(new IRVar(recList_matchNil), new IRSelfCall(recList_self)))
+])))));
 hoisted_recursiveList.hash;
-//*/
 // hoisted_foldr
 const foldr_reducer = Symbol("reduceFunc");
 const foldr_acc = Symbol("accumulator");
@@ -75,36 +92,49 @@ const foldr_head = Symbol("head");
 const foldr_tail = Symbol("tail");
 export const hoisted_foldr = new IRHoisted(new IRFunc([foldr_reducer, foldr_acc], _ir_apps(hoisted_recursiveList.clone(), new IRFunc([foldr__dummy], new IRDelayed(new IRVar(foldr_acc))), new IRFunc([foldr_self, foldr_head, foldr_tail], _ir_apps(new IRVar(foldr_reducer), new IRVar(foldr_head), new IRApp(new IRVar(foldr_self), new IRVar(foldr_tail)))))));
 hoisted_foldr.hash;
-export const hosited_lazyChooseList = new IRHoisted((() => {
-    const list = Symbol("list");
-    const delayed_caseNil = Symbol("delayed_caseNil");
-    const delayed_caseCons = Symbol("delayed_caseCons");
-    return new IRFunc([list, delayed_caseNil, delayed_caseCons], new IRForced(_ir_apps(IRNative.strictChooseList, new IRVar(list), new IRVar(delayed_caseNil), new IRVar(delayed_caseCons))));
-})());
-hosited_lazyChooseList.hash;
-//*/
 export const hoisted_isMoreThanOrEqualTo4 = new IRHoisted(_ir_apps(IRNative.lessThanInteger, IRConst.int(4)));
 hoisted_isMoreThanOrEqualTo4.hash;
 export const hoisted_sub4 = new IRHoisted(_ir_apps(IRNative.addInteger, IRConst.int(-4)));
 hoisted_sub4.hash;
 const self_length = Symbol("self_length");
 const length_list_sym = Symbol("length_list_sym");
-export const hoisted_length = new IRHoisted(new IRRecursive(self_length, new IRFunc([length_list_sym], _ir_lazyChooseList(new IRVar(length_list_sym), IRConst.int(0), _ir_apps(hoisted_incr.clone(), new IRApp(new IRSelfCall(self_length), // self
-new IRApp(IRNative.tailList, new IRVar(length_list_sym) // list
-)))))));
+export const hoisted_length = new IRHoisted(
+// new IRRecursive(
+//     self_length,
+//     new IRFunc(
+//         [ length_list_sym ],
+//         _ir_caseList(
+//             new IRVar( length_list_sym ),
+//             IRConst.int( 0 ),
+//             _ir_apps(
+//                 hoisted_incr.clone(),
+//                 new IRApp(
+//                     new IRSelfCall( self_length ), // self
+//                     new IRApp(
+//                         IRNative.tailList,
+//                         new IRVar( length_list_sym )  // list
+//                     )
+//                 )
+//             )
+//         )
+//     )
+// )
+new IRFunc([length_list_sym], _ir_apps(IRNative.lengthOfArray, _ir_apps(IRNative.listToArray, new IRVar(length_list_sym)))));
 hoisted_length.hash;
-// REPLACED hoisted_dropList (was numeric arity + dbn)
-const drop_self = Symbol("drop_self");
-const drop_n = Symbol("n");
-const drop_lst = Symbol("lst");
-export const hoisted_dropList = new IRHoisted(new IRRecursive(drop_self, new IRFunc([drop_n, drop_lst], _ir_lazyIfThenElse(_ir_apps(hoisted_isMoreThanOrEqualTo4.clone(), new IRVar(drop_n)), _ir_apps(new IRSelfCall(drop_self), _ir_apps(hoisted_sub4.clone(), new IRVar(drop_n)), _ir_apps(hoisted_drop4.clone(), new IRVar(drop_lst))), _ir_lazyIfThenElse(_ir_apps(hoisted_isZero.clone(), new IRVar(drop_n)), new IRVar(drop_lst), _ir_lazyIfThenElse(_ir_apps(hoisted_isOne.clone(), new IRVar(drop_n)), _ir_apps(IRNative.tailList, new IRVar(drop_lst)), _ir_lazyIfThenElse(_ir_apps(hoisted_isTwo.clone(), new IRVar(drop_n)), _ir_apps(hoisted_drop2.clone(), new IRVar(drop_lst)), _ir_apps(hoisted_drop3.clone(), new IRVar(drop_lst)))))))));
-hoisted_dropList.hash;
+//   λ reduce → recurse self → λ acc → λ list →
+//     case list of
+//       cons h t -> self (reduce acc h) t
+//       nil      -> acc
 const foldl_reduce = Symbol("reduceFunc");
 const foldl_self = Symbol("foldl_self");
 const foldl_acc = Symbol("accum");
+const foldl_list = Symbol("list");
 const foldl_head = Symbol("head");
 const foldl_tail = Symbol("tail");
-const hoiseted_foldl = new IRHoisted(new IRFunc([foldl_reduce], new IRRecursive(foldl_self, new IRFunc([foldl_acc], _ir_apps(hoisted_matchList.clone(), new IRDelayed(new IRVar(foldl_acc)), new IRFunc([foldl_head, foldl_tail], _ir_apps(new IRSelfCall(foldl_self), _ir_apps(new IRVar(foldl_reduce), new IRVar(foldl_acc), new IRVar(foldl_head)), new IRVar(foldl_tail))))))));
+const hoiseted_foldl = new IRHoisted(new IRFunc([foldl_reduce], new IRRecursive(foldl_self, new IRFunc([foldl_acc, foldl_list], new IRCase(new IRVar(foldl_list), [
+    new IRFunc([foldl_head, foldl_tail], _ir_apps(new IRSelfCall(foldl_self), _ir_apps(new IRVar(foldl_reduce), new IRVar(foldl_acc), new IRVar(foldl_head)), new IRVar(foldl_tail))),
+    new IRVar(foldl_acc)
+])))));
 hoiseted_foldl.hash;
 // hoisted _findSopOptional
 // (predicate: (a -> Bool)) -> (list: [a]) -> Optional<a>
@@ -112,7 +142,7 @@ const findSop_predicate = Symbol("predicate");
 const findSop_self = Symbol("findOpt_self");
 const findSop_list = Symbol("list");
 const findSop_head = Symbol("head");
-export const hoisted_findSopOptional = new IRHoisted(new IRFunc([findSop_predicate], new IRRecursive(findSop_self, new IRFunc([findSop_list], _ir_lazyChooseList(new IRVar(findSop_list), 
+export const hoisted_findSopOptional = new IRHoisted(new IRFunc([findSop_predicate], new IRRecursive(findSop_self, new IRFunc([findSop_list], _ir_caseList(new IRVar(findSop_list), 
 // case nil
 new IRConstr(1, []), // None
 // case cons
@@ -128,7 +158,7 @@ const lookup_key = Symbol("lookup_key");
 const lookup_self = Symbol("lookup_self");
 const lookup_map = Symbol("lookup_map");
 const lookup_head = Symbol("lookup_head");
-export const hoisted_lookupLinearMap = new IRHoisted(new IRFunc([lookup_key], new IRRecursive(lookup_self, new IRFunc([lookup_map], _ir_lazyChooseList(new IRVar(lookup_map), 
+export const hoisted_lookupLinearMap = new IRHoisted(new IRFunc([lookup_key], new IRRecursive(lookup_self, new IRFunc([lookup_map], _ir_caseList(new IRVar(lookup_map), 
 // case nil => None
 new IRConstr(1, []), 
 // case cons
@@ -146,7 +176,11 @@ const mkFind_pred = Symbol("predicate");
 const mkFind_self = Symbol("findOpt_self");
 const mkFind_list = Symbol("list");
 const mkFind_head = Symbol("head");
-export const hoisted_mkFindDataOptional = new IRHoisted(new IRFunc([mkFind_elemToData, mkFind_pred], new IRRecursive(mkFind_self, new IRFunc([mkFind_list], new IRForced(_ir_apps(new IRApp(IRNative.strictChooseList, new IRVar(mkFind_list)), new IRDelayed(IRConst.data(new DataConstr(1, []))), new IRDelayed(new IRApp(new IRFunc([mkFind_head], new IRForced(_ir_apps(IRNative.strictIfThenElse, new IRApp(new IRVar(mkFind_pred), new IRVar(mkFind_head)), new IRDelayed(_ir_apps(IRNative.constrData, IRConst.int(0), new IRApp(new IRVar(mkFind_elemToData), new IRVar(mkFind_head)))), new IRDelayed(new IRApp(new IRSelfCall(mkFind_self), new IRApp(IRNative.tailList, new IRVar(mkFind_list))))))), new IRApp(IRNative.headList, new IRVar(mkFind_list))))))))));
+const mkFind_tail = Symbol("tail");
+export const hoisted_mkFindDataOptional = new IRHoisted(new IRFunc([mkFind_elemToData, mkFind_pred], new IRRecursive(mkFind_self, new IRFunc([mkFind_list], new IRCase(new IRVar(mkFind_list), [
+    new IRFunc([mkFind_head, mkFind_tail], _ir_lazyIfThenElse(new IRApp(new IRVar(mkFind_pred), new IRVar(mkFind_head)), _ir_apps(IRNative.constrData, IRConst.int(0), new IRApp(new IRVar(mkFind_elemToData), new IRVar(mkFind_head))), new IRApp(new IRSelfCall(mkFind_self), new IRVar(mkFind_tail)))),
+    IRConst.data(new DataConstr(1, []))
+])))));
 hoisted_mkFindDataOptional.hash;
 // hoisted strictAnd / strictOr
 const strictAnd_a = Symbol("a");
@@ -161,7 +195,7 @@ hoisted_strictOr.hash;
 const some_pred = Symbol("predicate");
 const some_lst = Symbol("lst");
 const some_self = Symbol("self");
-export const hoisted_some = new IRHoisted(new IRFunc([some_pred], new IRRecursive(some_self, new IRFunc([some_lst], _ir_lazyChooseList(new IRVar(some_lst), IRConst.bool(false), // case nil => false
+export const hoisted_some = new IRHoisted(new IRFunc([some_pred], new IRRecursive(some_self, new IRFunc([some_lst], _ir_caseList(new IRVar(some_lst), IRConst.bool(false), // case nil => false
 _ir_or(
 // either predicate(head) is true
 _ir_apps(new IRVar(some_pred), new IRApp(IRNative.headList, new IRVar(some_lst))), 
@@ -172,7 +206,7 @@ hoisted_some.hash;
 const every_pred = Symbol("predicate");
 const every_self = Symbol("self");
 const every_lst = Symbol("lst");
-export const hoisted_every = new IRHoisted(new IRFunc([every_pred], new IRRecursive(every_self, new IRFunc([every_lst], _ir_lazyChooseList(new IRVar(every_lst), IRConst.bool(true), // case nil => true
+export const hoisted_every = new IRHoisted(new IRFunc([every_pred], new IRRecursive(every_self, new IRFunc([every_lst], _ir_caseList(new IRVar(every_lst), IRConst.bool(true), // case nil => true
 _ir_and(
 // both predicate(head) is true
 _ir_apps(new IRVar(every_pred), new IRApp(IRNative.headList, new IRVar(every_lst))), 
@@ -184,7 +218,7 @@ const filt_pred = Symbol("predicate");
 const filt_self = Symbol("filter_self");
 const filt_list = Symbol("list");
 const filt_elem = Symbol("elem");
-export const hoisted_filter = new IRHoisted(new IRFunc([filt_pred], new IRRecursive(filt_self, new IRFunc([filt_list], _ir_lazyChooseList(new IRVar(filt_list), 
+export const hoisted_filter = new IRHoisted(new IRFunc([filt_pred], new IRRecursive(filt_self, new IRFunc([filt_list], _ir_caseList(new IRVar(filt_list), 
 // case nil
 new IRVar(filt_list), // nil
 // case cons
@@ -285,7 +319,7 @@ export function nativeToIR(native) {
         case IRNativeTag._isZero: return hoisted_isZero.clone();
         case IRNativeTag._sortedValueLovelaces: return hoisted_sortedValueLovelaces.clone();
         case IRNativeTag._getCredentialsHash: return hoisted_getCredentialsHash.clone();
-        case IRNativeTag._dropList: return hoisted_dropList.clone();
+        // case IRNativeTag._dropList: return hoisted_dropList.clone();
         case IRNativeTag._mkMapList: return hoisted_mkMapList.clone();
         case IRNativeTag._increment: return hoisted_addOne.clone();
         case IRNativeTag._decrement: return hoisted_subOne.clone();
@@ -295,6 +329,8 @@ export function nativeToIR(native) {
         case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         case IRNativeTag._negateInt: return hoisted_negateInteger.clone();
         case IRNativeTag._lookupLinearMap: return hoisted_lookupLinearMap.clone();
+        case IRNativeTag._negateValue: return hoisted_negateValue.clone();
+        case IRNativeTag._valueEq: return hoisted_valueEq.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +
@@ -306,11 +342,11 @@ const eqList_eqFunc = Symbol("elemEq");
 const eqList_self = Symbol("eqList_self");
 const eqList_listA = Symbol("listA");
 const eqList_listB = Symbol("listB");
-export const hoisted_mkEqualsList = new IRHoisted(new IRFunc([eqList_eqFunc], new IRRecursive(eqList_self, new IRFunc([eqList_listA, eqList_listB], _ir_lazyChooseList(new IRVar(eqList_listA), 
+export const hoisted_mkEqualsList = new IRHoisted(new IRFunc([eqList_eqFunc], new IRRecursive(eqList_self, new IRFunc([eqList_listA, eqList_listB], _ir_caseList(new IRVar(eqList_listA), 
 // case nil: check if listB is also nil
 _ir_apps(IRNative.nullList, new IRVar(eqList_listB)), 
 // case cons
-_ir_lazyChooseList(new IRVar(eqList_listB), 
+_ir_caseList(new IRVar(eqList_listB), 
 // listB is nil => false
 IRConst.bool(false), 
 // both lists are cons
@@ -321,7 +357,7 @@ const mkMap_nil = Symbol("nilOfType");
 const mkMap_mapFunc = Symbol("mapFunc");
 const mkMap_map = Symbol("map_self");
 const mkMap_list = Symbol("list");
-export const hoisted_mkMapList = new IRHoisted(new IRFunc([mkMap_nil, mkMap_mapFunc], new IRRecursive(mkMap_map, new IRFunc([mkMap_list], _ir_lazyChooseList(new IRVar(mkMap_list), 
+export const hoisted_mkMapList = new IRHoisted(new IRFunc([mkMap_nil, mkMap_mapFunc], new IRRecursive(mkMap_map, new IRFunc([mkMap_list], _ir_caseList(new IRVar(mkMap_list), 
 // case nil: return nil of type
 new IRVar(mkMap_nil), 
 // case cons
@@ -348,28 +384,33 @@ const amount_tokenNameLoop = Symbol("tokenNameLoop_self");
 const amount_tokenMap = Symbol("tokenMap");
 export const hoisted_amountOfValue = new IRHoisted(new IRFunc([amount_isPolicy], // (policy => bool)
 new IRRecursive(amount_policyLoop, new IRFunc([amount_value], // value
-new IRForced(_ir_apps(IRNative.strictChooseList, new IRVar(amount_value), 
-// case nil: return (tokenName => 0)
-new IRDelayed(new IRFunc([amount_isTokenName], IRConst.int(0))), 
-// case cons
-new IRDelayed(_ir_let(_ir_apps(IRNative.headList, new IRVar(amount_value)), pairDataSym => new IRForced(_ir_apps(IRNative.strictIfThenElse, 
-// isPolicy( fst pairData as bytes )
-_ir_apps(new IRVar(amount_isPolicy), _ir_apps(IRNative.unBData, _ir_apps(IRNative.fstPair, new IRVar(pairDataSym)))), 
-// then: build (tokenName => amount)
-new IRDelayed(new IRFunc([amount_isTokenName], _ir_apps(new IRRecursive(amount_tokenNameLoop, new IRFunc([amount_tokenMap], new IRForced(_ir_apps(IRNative.strictChooseList, new IRVar(amount_tokenMap), 
-// token map empty => 0
-new IRDelayed(IRConst.int(0)), 
-// token map cons
-new IRDelayed(_ir_let(_ir_apps(IRNative.headList, new IRVar(amount_tokenMap)), pairDataTokenSym => new IRForced(_ir_apps(IRNative.strictIfThenElse, 
-// isTokenName( fst pairDataToken as bytes )
-_ir_apps(new IRVar(amount_isTokenName), _ir_apps(IRNative.unBData, _ir_apps(IRNative.fstPair, new IRVar(pairDataTokenSym)))), 
-// then: return amount
-new IRDelayed(_ir_apps(IRNative.unIData, _ir_apps(IRNative.sndPair, new IRVar(pairDataTokenSym)))), 
-// else: recurse tail
-new IRDelayed(_ir_apps(new IRSelfCall(amount_tokenNameLoop), _ir_apps(IRNative.tailList, new IRVar(amount_tokenMap) // tokenMap list
-))))))))))), 
-// pass token map (snd pairData)
-_ir_apps(IRNative.unMapData, _ir_apps(IRNative.sndPair, new IRVar(pairDataSym)))))), 
-// else: recurse policyLoop on tail value list
-new IRDelayed(_ir_apps(new IRSelfCall(amount_policyLoop), _ir_apps(IRNative.tailList, new IRVar(amount_value))))))))))))));
+(() => {
+    const valHead = Symbol("valHead");
+    const valTail = Symbol("valTail");
+    const tokHead = Symbol("tokHead");
+    const tokTail = Symbol("tokTail");
+    return new IRCase(new IRVar(amount_value), [
+        new IRFunc([valHead, valTail], _ir_lazyIfThenElse(
+        // isPolicy( unBData( fst valHead ) )
+        _ir_apps(new IRVar(amount_isPolicy), _ir_apps(IRNative.unBData, _ir_apps(IRNative.fstPair, new IRVar(valHead)))), 
+        // then: build (tokenName => amount)
+        new IRFunc([amount_isTokenName], _ir_apps(new IRRecursive(amount_tokenNameLoop, new IRFunc([amount_tokenMap], new IRCase(new IRVar(amount_tokenMap), [
+            new IRFunc([tokHead, tokTail], _ir_lazyIfThenElse(
+            // isTokenName( unBData( fst tokHead ) )
+            _ir_apps(new IRVar(amount_isTokenName), _ir_apps(IRNative.unBData, _ir_apps(IRNative.fstPair, new IRVar(tokHead)))), 
+            // then: return amount
+            _ir_apps(IRNative.unIData, _ir_apps(IRNative.sndPair, new IRVar(tokHead))), 
+            // else: recurse on tokTail
+            _ir_apps(new IRSelfCall(amount_tokenNameLoop), new IRVar(tokTail)))),
+            // token map empty => 0
+            IRConst.int(0)
+        ]))), 
+        // pass token map (unMapData( snd valHead ))
+        _ir_apps(IRNative.unMapData, _ir_apps(IRNative.sndPair, new IRVar(valHead))))), 
+        // else: recurse policyLoop on valTail
+        _ir_apps(new IRSelfCall(amount_policyLoop), new IRVar(valTail)))),
+        // case nil: return (tokenName => 0)
+        new IRFunc([amount_isTokenName], IRConst.int(0))
+    ]);
+})()))));
 hoisted_amountOfValue.hash;

package/dist/IR/toUPLC/subRoutines/rewriteHeadTailInCaseConsAndReturnRoot.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `case L of cons h t -> body | nil -> ...` already binds the list's head
+ * and tail to `h` and `t` in the cons branch. If `body` then re-extracts
+ * them via `headList(L)` / `tailList(L)`, those calls are redundant — the
+ * values are already in scope. This pass walks every `IRCase` whose
+ * scrutinee is a plain `IRVar(L)` and substitutes those head/tail calls
+ * inside the cons branch with `IRVar(h)` / `IRVar(t)`.
+ *
+ * Concretely, this turns
+ *
+ *     case body_xs of
+ *       cons body_xs_head body_xs_tail ->
+ *         ... headList(body_xs) ... tailList(body_xs) ...
+ *
+ * into
+ *
+ *     case body_xs of
+ *       cons body_xs_head body_xs_tail ->
+ *         ... body_xs_head ... body_xs_tail ...
+ *
+ * which (combined with `removeUnusedVarsAndReturnRoot`) drops the
+ * `(force headList) body_xs` / `(force tailList) body_xs` builtin
+ * applications entirely when the originally-bound `h`/`t` were unused.
+ *
+ * Substitution stops at any nested `IRFunc`/`IRRecursive` whose params
+ * shadow `L`, `h`, or `t` — those re-bindings would otherwise let us
+ * silently substitute a stale outer scope.
+ */
+import { IRTerm } from "../../IRTerm.js";
+export declare function rewriteHeadTailInCaseConsAndReturnRoot(term: IRTerm): IRTerm;

package/dist/IR/toUPLC/subRoutines/rewriteHeadTailInCaseConsAndReturnRoot.js

@@ -0,0 +1,95 @@
+/**
+ * `case L of cons h t -> body | nil -> ...` already binds the list's head
+ * and tail to `h` and `t` in the cons branch. If `body` then re-extracts
+ * them via `headList(L)` / `tailList(L)`, those calls are redundant — the
+ * values are already in scope. This pass walks every `IRCase` whose
+ * scrutinee is a plain `IRVar(L)` and substitutes those head/tail calls
+ * inside the cons branch with `IRVar(h)` / `IRVar(t)`.
+ *
+ * Concretely, this turns
+ *
+ *     case body_xs of
+ *       cons body_xs_head body_xs_tail ->
+ *         ... headList(body_xs) ... tailList(body_xs) ...
+ *
+ * into
+ *
+ *     case body_xs of
+ *       cons body_xs_head body_xs_tail ->
+ *         ... body_xs_head ... body_xs_tail ...
+ *
+ * which (combined with `removeUnusedVarsAndReturnRoot`) drops the
+ * `(force headList) body_xs` / `(force tailList) body_xs` builtin
+ * applications entirely when the originally-bound `h`/`t` were unused.
+ *
+ * Substitution stops at any nested `IRFunc`/`IRRecursive` whose params
+ * shadow `L`, `h`, or `t` — those re-bindings would otherwise let us
+ * silently substitute a stale outer scope.
+ */
+import { IRApp } from "../../IRNodes/IRApp.js";
+import { IRCase } from "../../IRNodes/IRCase.js";
+import { IRFunc } from "../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../IRNodes/IRLetted.js";
+import { IRNative } from "../../IRNodes/IRNative/index.js";
+import { IRNativeTag } from "../../IRNodes/IRNative/IRNativeTag.js";
+import { IRRecursive } from "../../IRNodes/IRRecursive.js";
+import { IRVar } from "../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+function unwrap(t) {
+    while (t instanceof IRHoisted)
+        t = t.hoisted;
+    while (t instanceof IRLetted)
+        t = t.value;
+    return t;
+}
+export function rewriteHeadTailInCaseConsAndReturnRoot(term) {
+    const stack = [term];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRCase) {
+            const scrutinee = t.constrTerm;
+            const consBranch = t.continuations[0];
+            if (scrutinee instanceof IRVar
+                && consBranch instanceof IRFunc
+                && consBranch.params.length === 2) {
+                const listSym = scrutinee.name;
+                const [hSym, tSym] = consBranch.params;
+                substituteHeadTailInBody(consBranch.body, listSym, hSym, tSym);
+            }
+        }
+        stack.push(...t.children());
+    }
+    return term;
+}
+function substituteHeadTailInBody(root, listSym, hSym, tSym) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        // Stop at a fresh binding that would shadow any of the symbols
+        // we're substituting for (extremely rare but cheap to guard).
+        if (t instanceof IRFunc || t instanceof IRRecursive) {
+            const params = t instanceof IRFunc ? t.params : [t.name];
+            if (params.includes(listSym)
+                || params.includes(hSym)
+                || params.includes(tSym))
+                continue;
+        }
+        if (t instanceof IRApp) {
+            const fn = unwrap(t.fn);
+            const arg = t.arg;
+            if (fn instanceof IRNative
+                && (fn.tag === IRNativeTag.headList || fn.tag === IRNativeTag.tailList)
+                && arg instanceof IRVar
+                && arg.name === listSym) {
+                const newSym = fn.tag === IRNativeTag.headList ? hSym : tSym;
+                const parent = t.parent;
+                if (parent !== undefined) {
+                    _modifyChildFromTo(parent, t, new IRVar(newSym));
+                }
+                continue;
+            }
+        }
+        stack.push(...t.children());
+    }
+}