@harmoniclabs/pebble 0.2.0 → 0.3.0

package/dist/compiler/tir/expressions/TirCaseExpr.js

@@ -1,20 +1,19 @@
 import { IRApp, _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { IRCase } from "../../../IR/IRNodes/IRCase.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
-import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 import { IRError } from "../../../IR/IRNodes/IRError.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRLetted } from "../../../IR/IRNodes/IRLetted.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
-import { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
-import { _ir_let, _ir_let_sym } from "../../../IR/tree_utils/_ir_let.js";
+import { _ir_let_sym } from "../../../IR/tree_utils/_ir_let.js";
 import { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
 import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
-import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
 import { _inlineFromData } from "./TirFromDataExpr.js";
 export class TirCaseExpr {
@@ -73,13 +72,83 @@ export class TirCaseExpr {
         if (matchExprType instanceof TirSoPStructType
             || matchExprType instanceof TirSopOptT)
             return this._sopStructToIR(matchExprType, ctx);
+        if (matchExprType instanceof TirDataStructType
+            && matchExprType.untagged)
+            return this._untaggedDataStructToIR(matchExprType, ctx);
         if (matchExprType instanceof TirDataStructType
             || matchExprType instanceof TirDataOptT)
             return this._dataStructToIR(matchExprType, ctx);
+        if (matchExprType instanceof TirEnumType)
+            return this._enumToIR(matchExprType, ctx);
         console.error(this);
         throw new Error("`case` expressions are only supported on Sum-of-Products or Data Struct types; got: "
             + this.matchExpr.type.toString());
     }
+    /**
+     * Lowers a `case` over an untagged data struct (single constructor;
+     * runtime form is `listData(fields)`). No constructor dispatch is
+     * needed — there's only one possible ctor — so the lowering is just
+     * "find the matching arm (or wildcard), extract any bound fields, run
+     * the body".
+     */
+    _untaggedDataStructToIR(matchExprType, ctx) {
+        if (matchExprType.constructors.length !== 1) {
+            throw new Error("untagged data struct must have exactly one constructor");
+        }
+        const ctor = matchExprType.constructors[0];
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
+        const matchedArm = this.cases.find(c => c.pattern.constrName === ctor.name);
+        if (!matchedArm) {
+            // no matching arm: just run the wildcard body (the scrutinee is
+            // evaluated for side-effects via `unListData` only if any field
+            // would have been bound; here, nothing).
+            return wildcardBodyIR;
+        }
+        const pattern = matchedArm.pattern;
+        const usedFields = ctor.fields
+            .map((f, idx) => ({ name: f.name, type: f.type, idx }))
+            .filter(f => pattern.fields.has(f.name));
+        // 0 bound fields → just run the body; no extraction.
+        if (usedFields.length === 0)
+            return matchedArm.body.toIR(ctx);
+        // fields-list = unListData(scrutinee), bound once and reused via
+        // IRLetted so the let-handling pass elides or shares as appropriate.
+        const fieldsListLetted = new IRLetted(Symbol("untaggedFields"), _ir_apps(IRNative.unListData, this.matchExpr.toIR(ctx)));
+        const branchCtx = ctx.newChild();
+        // bind each used field with a let in declaration order.
+        // sort by ctor field index so earlier extractions don't need to
+        // re-drop past already-bound fields.
+        usedFields.sort((a, b) => a.idx - b.idx);
+        const bindings = usedFields.map(f => {
+            const varDecl = pattern.fields.get(f.name);
+            if (!(varDecl instanceof TirSimpleVarDecl))
+                throw new Error("case pattern not expressified.");
+            const sym = branchCtx.defineVar(varDecl.name);
+            return {
+                sym,
+                extract: _inlineFromData(f.type, _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, IRConst.int(f.idx), fieldsListLetted.clone())))
+            };
+        });
+        // build nested let-bindings around the body
+        let result = matchedArm.body.toIR(branchCtx);
+        for (let i = bindings.length - 1; i >= 0; i--) {
+            const { sym, extract } = bindings[i];
+            result = _ir_let_sym(sym, extract, result);
+        }
+        return result;
+    }
+    _enumToIR(enumType, ctx) {
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
+        const branches = enumType.members.map(memberName => {
+            const branch = this.cases.find(c => c.pattern.constrName === memberName);
+            return branch ? branch.body.toIR(ctx) : wildcardBodyIR;
+        });
+        while (branches.length > 0 && branches[branches.length - 1] instanceof IRError)
+            branches.pop();
+        return branches.length > 0
+            ? new IRCase(this.matchExpr.toIR(ctx), branches)
+            : new IRError();
+    }
     _sopStructToIR(matchExprType, ctx) {
         if (matchExprType instanceof TirSopOptT) {
             const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
@@ -172,134 +241,87 @@ export class TirCaseExpr {
         return branches.length > 0 ? new IRCase(this.matchExpr.toIR(ctx), branches) : new IRError(); // all branches fail, so the whole expression fails
     }
     _dataStructToIR(matchExprType, ctx) {
-        if (matchExprType instanceof TirDataOptT) {
-            const stmtCtx = ctx.newChild();
-            stmtCtx.pushUnusedVar(); // debrujin un constr data result
-            const wildcardBodyIR = this.wildcardCase?.body.toIR(stmtCtx) ?? new IRError();
-            const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
-            let someBranchIR = () => new IRFunc([Symbol("unused_some_value")], wildcardBodyIR);
-            if (someBranch) {
-                const pattern = someBranch.pattern;
-                const valueDecl = pattern.fields.get("value");
-                if (valueDecl
-                    && !(valueDecl instanceof TirSimpleVarDecl))
-                    throw new Error("case pattern not expressified.");
-                const someBranchCtx = stmtCtx.newChild();
-                const someBranchVarSym = valueDecl ? someBranchCtx.defineVar(valueDecl.name) : Symbol("some_value_unused");
-                someBranchIR = (unConstrMatchSym) => new IRApp(new IRFunc([someBranchVarSym], someBranch.body.toIR(someBranchCtx)), _inlineFromData(getOptTypeArg(matchExprType), _ir_apps(IRNative.sndPair, new IRVar(unConstrMatchSym) // unConstrData result
-                )));
-            }
-            const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(stmtCtx) ?? wildcardBodyIR;
-            return _ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), unConstrMatchSym => _ir_lazyIfThenElse(
-            // condition
-            _ir_apps(IRNative.equalsInteger, IRConst.int(0), _ir_apps(IRNative.fstPair, new IRVar(unConstrMatchSym) // unConstrData result
-            )), 
-            // then Just{ value }
-            someBranchIR(unConstrMatchSym), 
-            // else None
-            noneBranchIR));
-        }
-        // TirDataStructType
-        const stmtCtx = ctx.newChild();
-        const unConstrStructSym = stmtCtx.pushUnusedVar("unconstrStruct"); // unconstrStruct
-        const isConstrIdxSym = stmtCtx.pushUnusedVar("isConstrIdx"); // isConstrIdx
-        const noVarsWildcardBodyIR = (this.wildcardCase?.body.toIR(stmtCtx)
-            ?? new IRError());
-        const delayedNoVarWildcardBodyIR = new IRDelayed(noVarsWildcardBodyIR);
-        let ifThenElseMatchingStatements = noVarsWildcardBodyIR;
+        // TirDataOptT extends TirDataStructType (constructors Some{value}, None{}),
+        // so the same logic handles it.
+        //
+        // Lowering structure (UPLC `Case` accepts pair / int scrutinees
+        // as untagged constructors):
+        //
+        //   Case (unConstrData scrutinee) [
+        //       \idxSym fieldsSym ->
+        //           Case idxSym [body_0, body_1, ..., body_(maxParent)]
+        //   ]
+        //
+        // - The outer `Case` over the `pair(int, list<data>)` returned by
+        //   `unConstrData` extracts both halves via a single 2-arg branch
+        //   (pair is treated as `constr 0 [fst, snd]`).
+        // - The inner `Case` over `idxSym` dispatches by tag in O(1) —
+        //   no `equalsInteger` chain, no `lazyIfThenElse`.
+        // - Each inner branch takes 0 args (an int N is treated as
+        //   `constr N []`). The branch body extracts fields lazily from
+        //   `fieldsSym` via deferred access on `thenCtx`, wrapped in
+        //   `IRLetted` so the letted-handling pass dedups, inlines or
+        //   elides as appropriate.
         if (this.cases.some(({ pattern }) => matchExprType.constructors.findIndex(ctor => ctor.name === pattern.constrName) < 0))
             throw new Error("case expression includes unknown constructor.");
-        const cases = this.cases.sort((a, b) => {
-            const a_idx = matchExprType.constructors.findIndex(ctor => ctor.name === a.pattern.constrName);
-            const b_idx = matchExprType.constructors.findIndex(ctor => ctor.name === b.pattern.constrName);
-            return a_idx - b_idx;
-        });
-        for (let i = cases.length - 1; i >= 0; i--) {
-            const { pattern, body } = cases[i];
+        const stmtCtx = ctx.newChild();
+        const wildcardBodyIR = this.wildcardCase?.body.toIR(stmtCtx) ?? new IRError();
+        // outer destructuring binders — symbols allocated up-front so
+        // per-arm deferred accesses (closures) reference the same syms
+        const idxSym = Symbol("ctorIdx");
+        const fieldsListSym = Symbol("fieldsList");
+        // The runtime value's ctor tag spans all parent indices known to
+        // this type — not just the indices that appear as arm patterns.
+        // Size the inner-Case branch array to cover all of them and fill
+        // missing slots with the wildcard.
+        const armsByParentIdx = new Map();
+        // TirDataOptT extends TirDataStructType, so both have parentCtorIdx
+        const allParentIdxs = matchExprType.constructors.map((_, i) => matchExprType.parentCtorIdx(i));
+        let maxParentIdx = allParentIdxs.reduce((m, x) => x > m ? x : m, -1);
+        for (const matchCase of this.cases) {
+            const { pattern, body } = matchCase;
             const ctorIdx = matchExprType.constructors.findIndex(ctor => ctor.name === pattern.constrName);
-            if (ctorIdx < 0)
-                throw new Error("case expression includes unknown constructor."); // unreachable
             const ctor = matchExprType.constructors[ctorIdx];
-            const usedFieldsCtorNames = (ctor.fields.map(f => f.name)
-                .filter(fName => pattern.fields.has(fName)));
-            if (usedFieldsCtorNames.length <= 0) {
-                ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-                // condition (compare against the PARENT ctor index — the
-                // value's runtime tag is unaffected by narrowing)
-                _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-                IRConst.int(matchExprType instanceof TirDataStructType
-                    ? matchExprType.parentCtorIdx(ctorIdx)
-                    : ctorIdx)), 
-                // then
-                body.toIR(stmtCtx), 
-                // else
-                ifThenElseMatchingStatements);
-                continue;
-            }
-            function indexOfField(fieldName) {
-                const idx = ctor.fields.findIndex(f => f.name === fieldName);
-                if (idx < 0)
-                    throw new Error("case pattern not expressified.");
-                return idx;
-            }
-            if (usedFieldsCtorNames.length === 1) {
-                const thenCtx = stmtCtx.newChild();
-                const fName = usedFieldsCtorNames[0];
+            const parentCtorIdx = matchExprType instanceof TirDataStructType
+                ? matchExprType.parentCtorIdx(ctorIdx)
+                : ctorIdx;
+            // bind each pattern-named field as a deferred access on
+            // `fieldsListSym`. Each access produces an `IRLetted`
+            // wrapping `_inlineFromData(type, headList(_dropList(idx, fields)))`.
+            const armCtx = stmtCtx.newChild();
+            const usedFieldsCtorNames = ctor.fields
+                .map(f => f.name)
+                .filter(fName => pattern.fields.has(fName));
+            for (const fName of usedFieldsCtorNames) {
                 const patternVarDecl = pattern.fields.get(fName);
                 if (!(patternVarDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
-                const introVar = thenCtx.defineVar(patternVarDecl.name);
-                const thenCase = _ir_let_sym(introVar, _inlineFromData(patternVarDecl.type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
-                _ir_apps(// fileds as data list
-                IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
-                )))), body.toIR(thenCtx));
-                ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-                // condition (compare against the PARENT ctor index — the
-                // value's runtime tag is unaffected by narrowing)
-                _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-                IRConst.int(matchExprType instanceof TirDataStructType
-                    ? matchExprType.parentCtorIdx(ctorIdx)
-                    : ctorIdx)), 
-                // then
-                thenCase, 
-                // else
-                ifThenElseMatchingStatements);
-                continue;
-            } // single field used edge case
-            // multiple fields used
-            const thenCtx = stmtCtx.newChild();
-            const fieldsAsDataList = thenCtx.pushUnusedVar(); // fileds as data list
-            const sortedUsedFields = [...usedFieldsCtorNames].sort((a, b) => indexOfField(a) - indexOfField(b));
-            const introducedVars = new Array(sortedUsedFields.length);
-            for (let fIdx = 0; fIdx < sortedUsedFields.length; fIdx++) {
-                const fName = sortedUsedFields[fIdx];
-                const patternVarDecl = pattern.fields.get(fName);
-                if (!(patternVarDecl instanceof TirSimpleVarDecl))
+                const fieldIdx = ctor.fields.findIndex(f => f.name === fName);
+                if (fieldIdx < 0)
                     throw new Error("case pattern not expressified.");
-                introducedVars[fIdx] = thenCtx.defineVar(patternVarDecl.name);
+                const fieldType = patternVarDecl.type;
+                armCtx.defineDeferredAccess(patternVarDecl.name, () => new IRLetted(Symbol(`${ctor.name}_${fName}`), _inlineFromData(fieldType, _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, IRConst.int(fieldIdx), new IRVar(fieldsListSym))))));
             }
-            const extractedFields = sortedUsedFields.map(fName => _inlineFromData(ctor.fields.find(f => f.name === fName).type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
-            new IRVar(fieldsAsDataList) // fileds as data list
-            ))));
-            const thenCase = _ir_let_sym(fieldsAsDataList, _ir_apps(IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
-            ), // fileds as data list
-            _ir_apps(new IRFunc(introducedVars, body.toIR(thenCtx)), ...extractedFields));
-            ifThenElseMatchingStatements = _ir_lazyIfThenElse(
-            // condition (compare against the PARENT ctor index — the
-            // value's runtime tag is unaffected by narrowing)
-            _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
-            IRConst.int(matchExprType instanceof TirDataStructType
-                ? matchExprType.parentCtorIdx(ctorIdx)
-                : ctorIdx)), 
-            // then
-            thenCase, 
-            // else
-            ifThenElseMatchingStatements);
+            armsByParentIdx.set(parentCtorIdx, body.toIR(armCtx));
+        }
+        // build inner-Case branches sized to `maxParentIdx + 1`, filling
+        // missing slots with the wildcard body
+        const innerBranches = new Array(maxParentIdx + 1);
+        for (let i = 0; i < innerBranches.length; i++) {
+            innerBranches[i] = armsByParentIdx.get(i) ?? wildcardBodyIR;
         }
-        return _ir_let_sym(unConstrStructSym, _ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), // unconstrStruct
-        _ir_let_sym(isConstrIdxSym, _ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(unConstrStructSym) // unConstrData result
-        )), // isConstrIdx
-        ifThenElseMatchingStatements));
+        // trailing `IRError` branches can be omitted — the CEK machine
+        // fails naturally if no branch exists for the runtime tag
+        while (innerBranches.length > 0
+            && innerBranches[innerBranches.length - 1] instanceof IRError)
+            innerBranches.pop();
+        const innerCase = innerBranches.length > 0
+            ? new IRCase(new IRVar(idxSym), innerBranches)
+            : new IRError();
+        // outer Case over the pair: single branch destructures (idx, fields)
+        return new IRCase(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), [
+            new IRFunc([idxSym, fieldsListSym], innerCase)
+        ]);
     }
 }
 export class TirCaseMatcher {

package/dist/compiler/tir/expressions/TirElemAccessExpr.js

@@ -44,8 +44,8 @@ export class TirElemAccessExpr {
             const result = Machine.evalSimple(compileIRToUPLC(irIndex));
             if ((result instanceof CEKConst)
                 && (typeof result.value === "number" || typeof result.value === "bigint"))
-                return _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(result.value), irArr));
+                return _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, IRConst.int(result.value), irArr));
         }
-        return _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, irIndex, irArr));
+        return _ir_apps(IRNative.headList, _ir_apps(IRNative.dropList, irIndex, irArr));
     }
 }

package/dist/compiler/tir/expressions/TirFromDataExpr.js

@@ -1,13 +1,11 @@
-import { _ir_apps, IRApp } from "../../../IR/IRNodes/IRApp.js";
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRConstr } from "../../../IR/IRNodes/IRConstr.js";
-import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
-import { _ir_let } from "../../../IR/tree_utils/_ir_let.js";
 import { TirBoolT } from "../types/TirNativeType/native/bool.js";
 import { TirBytesT } from "../types/TirNativeType/native/bytes.js";
 import { TirDataT } from "../types/TirNativeType/native/data.js";
@@ -19,7 +17,10 @@ import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
 import { TirStringT } from "../types/TirNativeType/native/string.js";
 import { TirVoidT } from "../types/TirNativeType/native/void.js";
+import { TirValueT } from "../types/TirNativeType/native/value.js";
+import { TirArrayT } from "../types/TirNativeType/native/array.js";
 import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { isTirType } from "../types/TirType.js";
 import { getListTypeArg } from "../types/utils/getListTypeArg.js";
 import { getOptTypeArg } from "../types/utils/getOptTypeArg.js";
@@ -68,6 +69,20 @@ export function _inlineFromData(target_t, dataExprIR) {
     // LinearMapEntry is Pair<Data,Data> at runtime — no conversion needed
     if (to_t instanceof TirLinearMapEntryT)
         return dataExprIR;
+    // Native Value: data -> Value via `unValueData`
+    if (to_t instanceof TirValueT)
+        return _ir_apps(IRNative.unValueData, dataExprIR);
+    // Native Array<T>: data -> [data] (unListData) -> Array<T>
+    // for non-data element types we map elements through their fromData first.
+    if (to_t instanceof TirArrayT) {
+        const elems_t = getUnaliased(to_t.typeArg);
+        const listOfDataExpr = _ir_apps(IRNative.unListData, dataExprIR);
+        if (elems_t instanceof TirDataStructType
+            || elems_t instanceof TirDataOptT
+            || elems_t instanceof TirDataT)
+            return _ir_apps(IRNative.listToArray, listOfDataExpr);
+        return _ir_apps(IRNative.listToArray, _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _fromDataUplcFunc(elems_t), listOfDataExpr));
+    }
     if (to_t instanceof TirListT) {
         const elems_t = getUnaliased(getListTypeArg(to_t));
         const listOfDataExpr = _ir_apps(IRNative.unListData, dataExprIR);
@@ -81,16 +96,24 @@ export function _inlineFromData(target_t, dataExprIR) {
         const value_t = getOptTypeArg(to_t);
         if (!isTirType(value_t))
             throw new Error("TirFromDataExpr: unreachable");
-        return _ir_let(// introuduce a var
-        _ir_apps(IRNative.unConstrData, dataExprIR), unConstrDataResultSym => _ir_apps(IRNative.strictIfThenElse, _ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(unConstrDataResultSym) // unConstrData result
-        ), IRConst.int(0)), 
-        // then (Just value)
-        new IRConstr(0, [
-            _ir_apps(_fromDataUplcFunc(value_t), _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, new IRVar(unConstrDataResultSym) // unConstrData result
-            )))
-        ]), 
-        // else (Nothing)
-        new IRHoisted(new IRConstr(1, []))));
+        // Case(unConstrData(data), [\idxSym fieldsSym ->
+        //     Case(idxSym, [
+        //         IRConstr(0, [fromData(headList(fieldsSym))]),  -- Some
+        //         IRConstr(1, [])                                -- None
+        //     ])
+        // ])
+        const idxSym = Symbol("optIdx");
+        const fieldsListSym = Symbol("optFields");
+        return new IRCase(_ir_apps(IRNative.unConstrData, dataExprIR), [
+            new IRFunc([idxSym, fieldsListSym], new IRCase(new IRVar(idxSym), [
+                // ctor 0: Some
+                new IRConstr(0, [
+                    _ir_apps(_fromDataUplcFunc(value_t), _ir_apps(IRNative.headList, new IRVar(fieldsListSym)))
+                ]),
+                // ctor 1: None
+                new IRHoisted(new IRConstr(1, []))
+            ]))
+        ]);
     }
     if (to_t instanceof TirSoPStructType) {
         return _inlineMultiSopConstrFromData(to_t, dataExprIR);
@@ -106,6 +129,8 @@ export function _fromDataUplcFunc(_target_t) {
         return IRNative._id;
     if (target_t instanceof TirIntT)
         return IRNative.unIData;
+    if (target_t instanceof TirEnumType)
+        return IRNative.unIData;
     if (target_t instanceof TirBytesT)
         return IRNative.unBData;
     if (target_t instanceof TirVoidT)
@@ -114,6 +139,9 @@ export function _fromDataUplcFunc(_target_t) {
         return _boolFromData.clone();
     if (target_t instanceof TirStringT)
         return _strFromData.clone();
+    // Native Value: data -> Value via `unValueData`
+    if (target_t instanceof TirValueT)
+        return IRNative.unValueData;
     if (target_t instanceof TirLinearMapT)
         // linear maps only have pairs as elements
         // and we only support pairs of data (bc we only have `mkPairData`)
@@ -136,8 +164,21 @@ export function _fromDataUplcFunc(_target_t) {
 const _unitFromDataSym = Symbol("unit");
 const _mkUnit = new IRHoisted(new IRFunc([_unitFromDataSym], IRConst.unit));
 const _boolFromDataDataSym = Symbol("boolData");
+// Case(unConstrData(data), [\idxSym _fieldsSym ->
+//     Case(idxSym, [
+//         IRConst.bool(true),   -- ctor 0 → true   (preserves equalsInteger(_, 0) semantics)
+//         IRConst.bool(false)   -- ctor 1 → false
+//     ])
+// ])
+const _boolFromDataIdxSym = Symbol("boolIdx");
+const _boolFromDataFieldsSym = Symbol("boolFields_unused");
 const _boolFromData = new IRHoisted(new IRFunc([_boolFromDataDataSym], // data
-_ir_apps(IRNative.equalsInteger, new IRApp(IRNative.fstPair, new IRApp(IRNative.unConstrData, new IRVar(_boolFromDataDataSym))), IRConst.int(0))));
+new IRCase(_ir_apps(IRNative.unConstrData, new IRVar(_boolFromDataDataSym)), [
+    new IRFunc([_boolFromDataIdxSym, _boolFromDataFieldsSym], new IRCase(new IRVar(_boolFromDataIdxSym), [
+        IRConst.bool(true),
+        IRConst.bool(false)
+    ]))
+])));
 const _strFromDataDataSym = Symbol("strData");
 const _strFromData = new IRHoisted(new IRFunc([_strFromDataDataSym], // data
 _ir_apps(IRNative.decodeUtf8, _ir_apps(IRNative.unBData, new IRVar(_strFromDataDataSym)))));
@@ -147,63 +188,57 @@ export function _inilneSingeSopConstrFromData(sop_t, dataExprIR) {
     const constr = sop_t.constructors[0];
     if (constr.fields.length === 0)
         return new IRHoisted(new IRConstr(0, []));
-    if (constr.fields.length === 1) {
-        const value_t = getUnaliased(constr.fields[0].type);
-        if (!isTirType(value_t))
-            throw new Error("TirFromDataExpr: unreachable");
-        return new IRConstr(0, [
-            _inlineFromData(value_t, 
-            // get head of fields list
-            _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, dataExprIR))))
-        ]);
-    }
-    return _ir_let(_ir_apps(IRNative.sndPair, _ir_apps(IRNative.unConstrData, dataExprIR)), // introduce fields list
-    // introduce fields list
-    fieldsListSym => new IRConstr(0, constr.fields.map((field, i) => {
-        const field_t = getUnaliased(field.type);
-        if (!isTirType(field_t))
-            throw new Error("TirFromDataExpr: unreachable");
-        return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
-            ? new IRVar(fieldsListSym)
-            : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(fieldsListSym))));
-    })));
+    // Case(unConstrData(data), [\_idxSym fieldsListSym -> IRConstr(0, [...fields])])
+    // Single ctor, so the index is ignored — the outer Case destructures
+    // the pair via a 2-arg branch and we only consume the fields list.
+    const idxSym = Symbol("singleCtorIdx_unused");
+    const fieldsListSym = Symbol("fieldsList");
+    return new IRCase(_ir_apps(IRNative.unConstrData, dataExprIR), [
+        new IRFunc([idxSym, fieldsListSym], new IRConstr(0, constr.fields.map((field, i) => {
+            const field_t = getUnaliased(field.type);
+            if (!isTirType(field_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
+                ? new IRVar(fieldsListSym)
+                : _ir_apps(IRNative.dropList, IRConst.int(i), new IRVar(fieldsListSym))));
+        })))
+    ]);
 }
 export function _inlineMultiSopConstrFromData(sop_t, dataExprIR) {
     if (sop_t.constructors.length <= 1)
         return _inilneSingeSopConstrFromData(sop_t, dataExprIR);
-    return _ir_let(_ir_apps(IRNative.unConstrData, dataExprIR), // introduce unConstrData result
-    // introduce unConstrData result
-    unConstrDataSym => _ir_let(_ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(unConstrDataSym))), // introduce isConstrIdx predicate (a function expecting an int)
-    // introduce isConstrIdx predicate (a function expecting an int)
-    isConstrIdxSym => _ir_let(_ir_apps(IRNative.sndPair, new IRVar(unConstrDataSym)), // introduce fields list
-    // introduce fields list
-    fieldsListSym => {
-        const continuations = sop_t.constructors.map((constr, constrIdx) => {
-            if (constr.fields.length === 0)
-                return new IRHoisted(new IRConstr(constrIdx, []));
-            if (constr.fields.length === 1) {
-                const value_t = getUnaliased(constr.fields[0].type);
-                if (!isTirType(value_t))
-                    throw new Error("TirFromDataExpr: unreachable");
-                return new IRConstr(constrIdx, [
-                    _inlineFromData(value_t, _ir_apps(IRNative.headList, new IRVar(fieldsListSym)))
-                ]);
-            }
-            return new IRConstr(constrIdx, constr.fields.map((field, i) => {
-                const field_t = getUnaliased(field.type);
-                if (!isTirType(field_t))
-                    throw new Error("TirFromDataExpr: unreachable");
-                return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
-                    ? new IRVar(fieldsListSym)
-                    : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(fieldsListSym))));
-            }));
-        });
-        let finalIfThenElseChain = continuations[continuations.length - 1];
-        for (let i = continuations.length - 2; i >= 0; i--) {
-            finalIfThenElseChain = new IRForced(_ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(isConstrIdxSym), IRConst.int(i)), new IRDelayed(continuations[i]), new IRDelayed(finalIfThenElseChain)));
+    // Case(unConstrData(data), [\idxSym fieldsListSym ->
+    //     Case(idxSym, [
+    //         IRConstr(0, [...fields_of_ctor_0]),
+    //         IRConstr(1, [...fields_of_ctor_1]),
+    //         ...
+    //     ])
+    // ])
+    const idxSym = Symbol("ctorIdx");
+    const fieldsListSym = Symbol("fieldsList");
+    const continuations = sop_t.constructors.map((constr, constrIdx) => {
+        if (constr.fields.length === 0)
+            return new IRHoisted(new IRConstr(constrIdx, []));
+        if (constr.fields.length === 1) {
+            const value_t = getUnaliased(constr.fields[0].type);
+            if (!isTirType(value_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return new IRConstr(constrIdx, [
+                _inlineFromData(value_t, _ir_apps(IRNative.headList, new IRVar(fieldsListSym)))
+            ]);
         }
-        return finalIfThenElseChain;
-    })));
+        return new IRConstr(constrIdx, constr.fields.map((field, i) => {
+            const field_t = getUnaliased(field.type);
+            if (!isTirType(field_t))
+                throw new Error("TirFromDataExpr: unreachable");
+            return _inlineFromData(field_t, _ir_apps(IRNative.headList, i === 0
+                ? new IRVar(fieldsListSym)
+                : _ir_apps(IRNative.dropList, IRConst.int(i), new IRVar(fieldsListSym))));
+        }));
+    });
+    return new IRCase(_ir_apps(IRNative.unConstrData, dataExprIR), [
+        new IRFunc([idxSym, fieldsListSym], new IRCase(new IRVar(idxSym), continuations))
+    ]);
 }
 // new cached hoisted helpers (mirroring TirToDataExpr pattern)
 const _mapListFromDataOfType = {};

package/dist/compiler/tir/expressions/TirIsExpr.js

@@ -4,6 +4,7 @@ import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { TirDataStructType, TirSoPStructType } from "../types/TirStructType.js";
+import { TirEnumType } from "../types/TirEnumType.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
 export class TirIsExpr {
     instanceExpr;
@@ -34,8 +35,20 @@ export class TirIsExpr {
     }
     get isConstant() { return this.instanceExpr.isConstant; }
     toIR(ctx) {
-        const structType = getUnaliased(this.instanceExpr.type);
+        const unaliased = getUnaliased(this.instanceExpr.type);
+        if (unaliased instanceof TirEnumType) {
+            // enums lower to a plain int; `is Member` is integer equality
+            return _ir_apps(IRNative.equalsInteger, IRConst.int(this.parentCtorIdx), this.instanceExpr.toIR(ctx));
+        }
+        const structType = unaliased;
         if (structType instanceof TirDataStructType) {
+            // untagged data structs have exactly one constructor; the
+            // runtime value carries no tag — `is Ctor` is statically true.
+            // We still evaluate `instanceExpr` to preserve any error it
+            // would produce (the redundancy is also flagged with a warning
+            // at AstCompiler time).
+            if (structType.untagged)
+                return _ir_apps(new IRFunc([Symbol("_unused_is_untagged")], IRConst.bool(true)), this.instanceExpr.toIR(ctx));
             // equalsInteger(parentCtorIdx, fstPair(unConstrData(<instance>)))
             return _ir_apps(IRNative.equalsInteger, IRConst.int(this.parentCtorIdx), _ir_apps(IRNative.fstPair, _ir_apps(IRNative.unConstrData, this.instanceExpr.toIR(ctx))));
         }

package/dist/compiler/tir/expressions/TirNativeFunc.d.ts

@@ -42,7 +42,6 @@ export declare class TirNativeFunc implements ITirExpr {
     static get verifyEd25519Signature(): TirNativeFunc;
     static strictIfThenElse(returnT: TirType): TirNativeFunc;
     static chooseUnit(returnT: TirType): TirNativeFunc;
-    static strictChooseList(elemT: TirType, returnT: TirType): TirNativeFunc;
     static mkCons(elemT: TirType): TirNativeFunc;
     static headList(elemT: TirType): TirNativeFunc;
     static tailList(elemT: TirType): TirNativeFunc;
@@ -98,7 +97,7 @@ export declare class TirNativeFunc implements ITirExpr {
     static get countSetBits(): TirNativeFunc;
     static get findFirstSetBit(): TirNativeFunc;
     static get ripemd_160(): TirNativeFunc;
-    static _dropList(elemT: TirType): TirNativeFunc;
+    static dropList(elemT: TirType): TirNativeFunc;
     static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _findSopOptional(elems_t: TirType): TirNativeFunc;