@harmoniclabs/pebble 0.2.0 → 0.3.0

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());
+    }
+}

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

@@ -1,6 +1,7 @@
 import { TirBoolT, TirIntT } from "../../../compiler/tir/types/TirNativeType/index.js";
 import { equalIrHash } from "../../IRHash.js";
 import { _ir_apps } from "../../IRNodes/IRApp.js";
+import { IRCase } from "../../IRNodes/IRCase.js";
 import { IRConst } from "../../IRNodes/IRConst.js";
 import { IRFunc } from "../../IRNodes/IRFunc.js";
 import { IRHoisted } from "../../IRNodes/IRHoisted.js";
@@ -125,8 +126,14 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
                     if (isListLength(eqZeroArgFunc)
                         && eqZeroArgArgs.length === 1) {
                         const listTerm = eqZeroArgArgs[0];
-                        // replace with isNullList
-                        const newTerm = _ir_apps(IRNative.strictChooseList, listTerm, thenArg, elseArg);
+                        // if( list.length() === 0 ) thenArg else elseArg
+                        //   →  case list of cons _h _t -> elseArg ; nil -> thenArg
+                        const dh = Symbol("_h");
+                        const dt = Symbol("_t");
+                        const newTerm = new IRCase(listTerm, [
+                            new IRFunc([dh, dt], elseArg),
+                            thenArg
+                        ]);
                         modifyTermAndPushToReprocess(current, newTerm);
                         continue;
                     }
@@ -137,8 +144,14 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
                 else if (isNullList(condFunc)
                     && condArgs.length === 1) {
                     const listTerm = condArgs[0];
-                    // replace with isListLength
-                    const newTerm = _ir_apps(IRNative.strictChooseList, listTerm, thenArg, elseArg);
+                    // if( nullList(list) ) thenArg else elseArg
+                    //   →  case list of cons _h _t -> elseArg ; nil -> thenArg
+                    const dh = Symbol("_h");
+                    const dt = Symbol("_t");
+                    const newTerm = new IRCase(listTerm, [
+                        new IRFunc([dh, dt], elseArg),
+                        thenArg
+                    ]);
                     modifyTermAndPushToReprocess(current, newTerm);
                     continue;
                 } // if( x.isEmpty() )
@@ -227,6 +240,24 @@ export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
                     continue;
                 }
             }
+            else if (tag === IRNativeTag.strictChooseList
+                && restArgs.length === 2) {
+                // strictChooseList list caseNil caseCons
+                //   →  case list of (λ_h _t → caseCons) | caseNil
+                // IRCase branches are naturally lazy, so wrapping caseNil/
+                // caseCons in delay/force is unnecessary at the call site.
+                const listTerm = fstArg;
+                const caseNil = restArgs[0];
+                const caseCons = restArgs[1];
+                const dh = Symbol("_h");
+                const dt = Symbol("_t");
+                const newTerm = new IRCase(listTerm, [
+                    new IRFunc([dh, dt], caseCons),
+                    caseNil
+                ]);
+                modifyTermAndPushToReprocess(current, newTerm);
+                continue;
+            }
         }
         // only optimizations if first argument is constant after this point
         if (!(fstArg instanceof IRConst)) {
@@ -254,7 +285,7 @@ function isDropList(term) {
             term = term.value;
     }
     return (term instanceof IRNative
-        && term.tag === IRNativeTag._dropList);
+        && term.tag === IRNativeTag.dropList);
 }
 function isId(term) {
     while (term instanceof IRHoisted

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

@@ -0,0 +1,35 @@
+/**
+ * Case-over-Const lowering pass.
+ *
+ * The UPLC `Case` term accepts a constant scrutinee and reinterprets it
+ * as a tag-untagged constructor (bool → 0/1, int N → N, unit → 0,
+ * pair → constr 0 [fst, snd], list → constr 1 [] for `[]` or
+ * constr 0 [head, tail] for cons).
+ *
+ * This pass replaces canonical `strictIfThenElse(cond, then, else)`
+ * sequences with the equivalent `IRCase(cond, [else, then])` form. The
+ * machine resolves bool=false → constr 0, bool=true → constr 1.
+ * This subsumes the strict boolean helpers (`_not`, `_strictAnd`,
+ * `_strictOr`) whose hoisted bodies are themselves `strictIfThenElse`
+ * triple-apps — they get lowered inside their hoisted definitions.
+ *
+ * It also replaces the LAZY pattern emitted by `_ir_lazyIfThenElse`:
+ *
+ *     IRForced( strictIfThenElse cond (delay t) (delay e) )
+ *
+ * — which is how `&&`, `||` and pebble `if/else` are encoded today —
+ * with `IRCase(cond, [e, t])`. Branches under `Case` are naturally
+ * lazy, so the surrounding `force`/`delay` indirection is dropped.
+ *
+ * It also prunes trailing IRError continuations: a missing branch is
+ * semantically equivalent to an evaluation-failure branch, so dropping a
+ * trailing `IRError` reduces script size while preserving meaning.
+ *
+ * NOTE: `getApplicationTerms` sees through both raw `IRApp` chains AND
+ * the case-constr-app encoding produced earlier in `performUplc…`
+ * (i.e. `IRCase(IRConstr(0, [args]), [func])`). We therefore check the
+ * app-pattern *before* the IRCase trailing-error pruning so that a case
+ * that's really a function call gets unwrapped first.
+ */
+import { IRTerm } from "../../IRTerm.js";
+export declare function rewriteToCaseOverConstAndReturnRoot(term: IRTerm): IRTerm;