@harmoniclabs/pebble 0.1.0-dev4 → 0.1.0-dev6

package/dist/compiler/io/IOutputStream.js

@@ -1,11 +1,26 @@
 import { fromUtf8, concatUint8Array, toUtf8 } from "@harmoniclabs/uint8array-utils";
 export class ConsoleLogStream {
+    _pending = "";
     write(chunk) {
-        if (chunk instanceof Uint8Array) {
-            console.log(toUtf8(chunk));
+        const newChunk = (chunk instanceof Uint8Array) ? toUtf8(chunk) : chunk.toString();
+        if (newChunk.includes("\n")) {
+            const parts = newChunk.split("\n");
+            if (parts.length === 1) {
+                // only one \n
+                console.log(this._pending + parts[0]);
+                this._pending = "";
+            }
+            else {
+                // multiple \n
+                console.log(this._pending + parts[0]);
+                for (let i = 1; i < parts.length - 1; i++) {
+                    console.log(parts[i]);
+                }
+                this._pending = parts[parts.length - 1];
+            }
         }
         else {
-            console.log(chunk.toString());
+            this._pending += newChunk;
         }
     }
 }

package/dist/compiler/path/getAbsolutePath.d.ts

@@ -1,3 +1,4 @@
+export declare function isAbsolutePath(path: string): boolean;
 export declare function getEnvRelativePath(filePath: string, projectRoot: string): string | undefined;
 /**
  * Takes a relative path and an absolute path, and returns the absolute path

package/dist/compiler/path/getAbsolutePath.js

@@ -51,19 +51,22 @@ function addExtension(path, endsWithSlash) {
     // Otherwise just add the extension
     return path + extension;
 }
+export function isAbsolutePath(path) {
+    return path.startsWith(PATH_DELIMITER);
+}
 export function getEnvRelativePath(filePath, projectRoot) {
     if (!(typeof filePath === 'string' &&
         typeof projectRoot === 'string'))
         return undefined;
     projectRoot = projectRoot.trim();
+    if (!projectRoot.endsWith(PATH_DELIMITER))
+        projectRoot += PATH_DELIMITER;
+    if (isAbsolutePath(filePath))
+        return filePath;
     filePath = getAbsolutePath(filePath.trim(), projectRoot);
     if (!filePath)
         return undefined;
-    if (!projectRoot.endsWith(PATH_DELIMITER))
-        projectRoot = projectRoot + PATH_DELIMITER;
-    while (filePath.startsWith(PATH_DELIMITER))
-        filePath = filePath.slice(PATH_DELIMITER.length);
-    return projectRoot + filePath;
+    return filePath.startsWith(projectRoot) ? filePath : projectRoot + filePath;
 }
 /**
  * Takes a relative path and an absolute path, and returns the absolute path

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

@@ -8,4 +8,6 @@ export interface ITirExpr extends HasSourceRange {
     deps: () => string[];
     toIR: (ctx: ToIRTermCtx) => IRTerm;
     clone: () => ITirExpr;
+    toString: () => string;
+    pretty: (indent: number) => string;
 }

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

@@ -1,5 +1,5 @@
 import { SourceRange } from "../../../ast/Source/SourceRange.js";
-import { IRTerm } from "../../../IR/IRTerm.js";
+import type { IRTerm } from "../../../IR/IRTerm.js";
 import { TirAssertStmt } from "../statements/TirAssertStmt.js";
 import { TirType } from "../types/TirType.js";
 import { ITirExpr } from "./ITirExpr.js";
@@ -11,7 +11,9 @@ export declare class TirAssertAndContinueExpr implements ITirExpr {
     readonly range: SourceRange;
     get type(): TirType;
     constructor(conditions: TirExpr[], continuation: TirExpr, range: SourceRange);
-    clone(): TirAssertAndContinueExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     static fromStmtsAndContinuation(assertions: TirAssertStmt[], continuation: TirExpr): TirExpr;
     deps(): string[];
     get isConstant(): boolean;

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

@@ -1,8 +1,8 @@
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 import { IRError } from "../../../IR/IRNodes/IRError.js";
 import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
-import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 export class TirAssertAndContinueExpr {
     conditions;
@@ -16,6 +16,18 @@ export class TirAssertAndContinueExpr {
         this.continuation = continuation;
         this.range = range;
     }
+    toString() {
+        return `assert ${this.conditions.map(c => c.toString()).join(" && ")} then ${this.continuation.toString()}`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        const conditionsPart = this.conditions.map(c => c.pretty(indent)).join(` &&${indent_1}`);
+        return (`assert ${conditionsPart}` +
+            `${indent_0}then ${this.continuation.pretty(indent)}`);
+    }
     /// @ts-ignore Return type annotation circularly references itself.
     clone() {
         return new TirAssertAndContinueExpr(this.conditions.map(c => c.clone()), this.continuation.clone(), this.range.clone());
@@ -23,7 +35,9 @@ export class TirAssertAndContinueExpr {
     static fromStmtsAndContinuation(assertions, continuation) {
         if (assertions.length <= 0)
             return continuation;
-        return new TirAssertAndContinueExpr(assertions.map(a => a.toSafeCondition()), continuation, continuation.range);
+        const correctAssertions = assertions.map(a => a.toSafeCondition());
+        assertions.length = 0;
+        return new TirAssertAndContinueExpr(correctAssertions, continuation, continuation.range);
     }
     deps() {
         return (this.conditions

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

@@ -10,7 +10,9 @@ export declare class TirCallExpr implements ITirExpr {
     readonly type: TirType;
     readonly range: SourceRange;
     constructor(func: TirExpr, args: TirExpr[], type: TirType, range: SourceRange);
-    clone(): TirCallExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     deps(): string[];
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;

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

@@ -1,4 +1,4 @@
-import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 export class TirCallExpr {
     func;
@@ -11,6 +11,21 @@ export class TirCallExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `${this.func.toString()}( ${this.args.map(a => a.toString()).join(", ")} )`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        if (this.args.length === 0) {
+            return `${this.func.pretty(indent)}()`;
+        }
+        return (`${this.func.pretty(indent)}(` +
+            indent_1 + this.args.map(arg => arg.pretty(indent + 1)).join(`,${indent_1}`) +
+            `${indent_0})`);
+    }
     clone() {
         return new TirCallExpr(this.func.clone(), this.args.map(a => a.clone()), this.type.clone(), this.range.clone());
     }

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

@@ -12,8 +12,11 @@ export declare class TirCaseExpr implements ITirExpr {
     readonly wildcardCase: TirWildcardCaseMatcher | undefined;
     readonly type: TirType;
     readonly range: SourceRange;
+    private readonly _creationStack;
     constructor(matchExpr: TirExpr, cases: TirCaseMatcher[], wildcardCase: TirWildcardCaseMatcher | undefined, type: TirType, range: SourceRange);
-    clone(): TirCaseExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     deps(): string[];
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
@@ -27,10 +30,12 @@ export declare class TirCaseMatcher implements HasSourceRange {
     readonly range: SourceRange;
     constructor(pattern: TirCasePattern, body: TirExpr, range: SourceRange);
     deps(): string[];
+    pretty(indent: number): string;
 }
 export declare class TirWildcardCaseMatcher implements HasSourceRange {
     body: TirExpr;
     readonly range: SourceRange;
     constructor(body: TirExpr, range: SourceRange);
     deps(): string[];
+    pretty(indent: number): string;
 }

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

@@ -1,3 +1,4 @@
+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";
@@ -6,8 +7,8 @@ import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
-import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
-import { _ir_let } from "../../../IR/tree_utils/_ir_let.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 { filterSortedStrArrInplace } from "../../../utils/array/filterSortedStrArrInplace.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
@@ -23,12 +24,35 @@ export class TirCaseExpr {
     wildcardCase;
     type;
     range;
+    _creationStack;
     constructor(matchExpr, cases, wildcardCase, type, range) {
         this.matchExpr = matchExpr;
         this.cases = cases;
         this.wildcardCase = wildcardCase;
         this.type = type;
         this.range = range;
+        // this._creationStack = (new Error()).stack;
+    }
+    toString() {
+        const casesStr = this.cases.map(c => `is ${c.pattern.toString()} => ${c.body.toString()}`).join(" ");
+        const wildcardStr = this.wildcardCase
+            ? `else ${this.wildcardCase.body.toString()}`
+            : "";
+        return `(case ${this.matchExpr.toString()} ${casesStr} ${wildcardStr})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        const casesPart = this.cases.map(c => `${indent_1}is ${c.pattern.pretty(indent + 1)} => ${c.body.pretty(indent + 1)}`).join("");
+        const wildcardPart = this.wildcardCase
+            ? `${indent_1}else ${this.wildcardCase.body.pretty(indent + 1)}`
+            : "";
+        return (`(case ${this.matchExpr.pretty(indent + 1)}` +
+            casesPart +
+            wildcardPart +
+            `${indent_0})`);
     }
     /// @ts-ignore Return type annotation circularly references itself.
     clone() {
@@ -52,6 +76,7 @@ export class TirCaseExpr {
         if (matchExprType instanceof TirDataStructType
             || matchExprType instanceof TirDataOptT)
             return this._dataStructToIR(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());
     }
@@ -60,45 +85,52 @@ export class TirCaseExpr {
             const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
             const someBranchCtx = ctx.newChild();
             const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
+            let someBranchVarSym = Symbol("some_value_unused");
             if (someBranch) {
                 const varDecl = someBranch.pattern.fields.values().next().value;
                 if (!(varDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
-                someBranchCtx.defineVar(varDecl.name);
+                someBranchVarSym = someBranchCtx.defineVar(varDecl.name);
             }
             const someBranchIR = someBranch?.body.toIR(someBranchCtx) ?? wildcardBodyIR;
             const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(ctx) ?? wildcardBodyIR;
             return new IRCase(this.matchExpr.toIR(ctx), [
                 // Some{ value }
-                new IRFunc(1, someBranchIR),
+                new IRFunc([someBranchVarSym], someBranchIR),
                 // None
                 noneBranchIR
             ]);
         }
         // TirSopStructType
         const wildcardBodyIR = this.wildcardCase?.body.toIR(ctx) ?? new IRError();
-        const branches = matchExprType.constructors.map(ctor => {
-            const wrapBody = ctor.fields.length === 0
-                ? (body) => body
-                : (body) => new IRFunc(ctor.fields.length, body);
+        const branches = matchExprType.constructors.map((ctor, ctorIdx) => {
+            const nFields = ctor.fields.length;
             const branchCtx = ctx.newChild();
             const branch = this.cases.find(c => c.pattern.constrName === ctor.name);
-            if (!branch)
-                return wrapBody(wildcardBodyIR);
+            if (!branch) {
+                if (nFields <= 0)
+                    return wildcardBodyIR;
+                const introducedVars = Array(nFields).fill(0).map(() => branchCtx.pushUnusedVar());
+                return new IRFunc(introducedVars, wildcardBodyIR);
+            }
             const pattern = branch.pattern;
-            for (const field of ctor.fields) {
+            const introducedVars = new Array(nFields);
+            for (let i = 0; i < nFields; i++) {
+                const field = ctor.fields[i];
                 const varDecl = pattern.fields.get(field.name);
                 if (!varDecl) {
                     // increment debrujin
                     // variable is still introduced, even if unused
-                    branchCtx.pushUnusedVar();
+                    introducedVars[i] = branchCtx.pushUnusedVar();
                     continue;
                 }
                 if (!(varDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
-                branchCtx.defineVar(varDecl.name);
+                introducedVars[i] = branchCtx.defineVar(varDecl.name);
             }
-            return wrapBody(branch.body.toIR(branchCtx));
+            if (nFields <= 0)
+                return branch.body.toIR(branchCtx);
+            return new IRFunc(introducedVars, branch.body.toIR(branchCtx));
         });
         // branches at the end that are supposed to "just fail"
         // can be omitted, as the CEK machine will fail if no branch for
@@ -107,46 +139,38 @@ export class TirCaseExpr {
             branches.pop();
         return branches.length > 0 ? new IRCase(this.matchExpr.toIR(ctx), branches) : new IRError(); // all branches fail, so the whole expression fails
     }
-    // TODO: optimization
-    // expect data-encoded patterns to be empty after `expressify`
-    // because accessed field should use `IRLetted` instead
     _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 someBranchCtx = stmtCtx.newChild();
             const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
+            let someBranchIR = () => new IRFunc([Symbol("unused_some_value")], wildcardBodyIR);
             if (someBranch) {
-                const varDecl = someBranch.pattern.fields.values().next().value;
-                if (varDecl === undefined) {
-                    // increment debrujin
-                    // variable is still introduced, even if unused
-                    someBranchCtx.pushUnusedVar();
-                }
-                else {
-                    if (!(varDecl instanceof TirSimpleVarDecl))
-                        throw new Error("case pattern not expressified.");
-                    someBranchCtx.defineVar(varDecl.name);
-                }
+                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 someBranchIR = someBranch?.body.toIR(someBranchCtx); // ?? wildcardBodyIR;
             const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(stmtCtx) ?? wildcardBodyIR;
-            if (someBranchIR instanceof IRError && noneBranchIR instanceof IRError)
-                return new IRError();
-            return new IRForced(_ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), _ir_apps(IRNative.strictIfThenElse, _ir_apps(IRNative.equalsInteger, IRConst.int(0), _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+            return new IRForced(_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 ? new IRDelayed(wildcardBodyIR) :
-                _ir_let(_inlineFromData(getOptTypeArg(matchExprType), _ir_apps(IRNative.sndPair, new IRVar(0) // unConstrData result
-                )), new IRDelayed(someBranchIR)), 
+            someBranchIR(unConstrMatchSym), 
             // else None
-            new IRDelayed(noneBranchIR))));
+            noneBranchIR)));
         }
         // TirDataStructType
         const stmtCtx = ctx.newChild();
-        stmtCtx.pushUnusedVar(); // unconstrStruct
-        stmtCtx.pushUnusedVar(); // isConstrIdx
+        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);
@@ -167,12 +191,14 @@ export class TirCaseExpr {
             const usedFieldsCtorNames = (ctor.fields.map(f => f.name)
                 .filter(fName => pattern.fields.has(fName)));
             if (usedFieldsCtorNames.length <= 0) {
-                ifThenElseMatchingStatements = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(0), // isConstrIdx
+                ifThenElseMatchingStatements = _ir_lazyIfThenElse(
+                // condition
+                _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
                 IRConst.int(ctorIdx)), 
                 // then
-                new IRDelayed(body.toIR(stmtCtx)), 
+                body.toIR(stmtCtx), 
                 // else
-                new IRDelayed(ifThenElseMatchingStatements));
+                ifThenElseMatchingStatements);
                 continue;
             }
             function indexOfField(fieldName) {
@@ -187,45 +213,52 @@ export class TirCaseExpr {
                 const patternVarDecl = pattern.fields.get(fName);
                 if (!(patternVarDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
-                thenCtx.defineVar(patternVarDecl.name);
-                const thenCase = _ir_let(_inlineFromData(patternVarDecl.type, _ir_apps(IRNative.headList, _ir_apps(IRNative._dropList, IRConst.int(indexOfField(fName)), // constr field index
+                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(1) // uncostrStruct
+                IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
                 )))), body.toIR(thenCtx));
-                ifThenElseMatchingStatements = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(0), // isConstrIdx
+                ifThenElseMatchingStatements = _ir_lazyIfThenElse(
+                // condition
+                _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
                 IRConst.int(ctorIdx)), 
                 // then
-                new IRDelayed(thenCase), 
+                thenCase, 
                 // else
-                new IRDelayed(ifThenElseMatchingStatements));
+                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));
-            for (const fName of sortedUsedFields) {
+            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))
                     throw new Error("case pattern not expressified.");
-                thenCtx.defineVar(patternVarDecl.name);
+                introducedVars[fIdx] = thenCtx.defineVar(patternVarDecl.name);
             }
             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(0) // fileds as data list
+            new IRVar(fieldsAsDataList) // fileds as data list
             ))));
-            const thenCase = _ir_let(_ir_apps(IRNative.sndPair, new IRVar(1) // uncostrStruct
+            const thenCase = _ir_let_sym(fieldsAsDataList, _ir_apps(IRNative.sndPair, new IRVar(unConstrStructSym) // unconstrStruct
             ), // fileds as data list
-            _ir_apps(new IRFunc(sortedUsedFields.length, body.toIR(thenCtx)), ...extractedFields));
-            ifThenElseMatchingStatements = _ir_apps(IRNative.strictIfThenElse, _ir_apps(new IRVar(0), // isConstrIdx
+            _ir_apps(new IRFunc(introducedVars, body.toIR(thenCtx)), ...extractedFields));
+            ifThenElseMatchingStatements = _ir_lazyIfThenElse(
+            // condition
+            _ir_apps(new IRVar(isConstrIdxSym), // isConstrIdx
             IRConst.int(ctorIdx)), 
             // then
-            new IRDelayed(thenCase), 
+            thenCase, 
             // else
-            new IRDelayed(ifThenElseMatchingStatements));
+            ifThenElseMatchingStatements);
         }
-        return new IRForced(_ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), // uncostrStruct
-        _ir_let(_ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+        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)));
+        ifThenElseMatchingStatements));
     }
 }
 export class TirCaseMatcher {
@@ -243,6 +276,11 @@ export class TirCaseMatcher {
         filterSortedStrArrInplace(deps, nonDeps);
         return deps;
     }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `is ${this.pattern.pretty(indent)} => ${this.body.pretty(indent)}`;
+    }
 }
 export class TirWildcardCaseMatcher {
     body;
@@ -254,4 +292,9 @@ export class TirWildcardCaseMatcher {
     deps() {
         return this.body.deps();
     }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `else ${this.body.pretty(indent)}`;
+    }
 }

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

@@ -13,7 +13,9 @@ export declare class TirElemAccessExpr implements ITirExpr {
     readonly type: TirType;
     readonly range: SourceRange;
     constructor(arrLikeExpr: TirExpr, indexExpr: TirExpr, type: TirType, range: SourceRange);
-    clone(): TirElemAccessExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     deps(): string[];
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;

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

@@ -2,8 +2,8 @@ import { CEKConst, Machine } from "@harmoniclabs/plutus-machine";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
-import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
 import { compileIRToUPLC } from "../../../IR/toUPLC/compileIRToUPLC.js";
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 /**
  * `arrLikeExpr[ indexExpr ]`
  */
@@ -18,6 +18,14 @@ export class TirElemAccessExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `${this.arrLikeExpr.toString()}[ ${this.indexExpr.toString()} ]`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `${this.arrLikeExpr.pretty(indent)}[ ${this.indexExpr.pretty(indent)} ]`;
+    }
     clone() {
         return new TirElemAccessExpr(this.arrLikeExpr.clone(), this.indexExpr.clone(), this.type.clone(), this.range.clone());
     }

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

@@ -12,7 +12,9 @@ export declare class TirFailExpr implements ITirExpr {
     constructor(
     /** must be string (or utf8 bytes) */
     failMsgExpr: TirExpr | undefined, type: TirType, range: SourceRange);
-    clone(): TirFailExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     deps(): string[];
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;

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

@@ -1,6 +1,6 @@
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { IRError } from "../../../IR/IRNodes/IRError.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
-import { _ir_apps } from "../../../IR/tree_utils/_ir_apps.js";
 export class TirFailExpr {
     failMsgExpr;
     type;
@@ -12,6 +12,14 @@ export class TirFailExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `(fail${this.failMsgExpr ? ` ${this.failMsgExpr.toString()}` : ""})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `(fail${this.failMsgExpr ? ` ${this.failMsgExpr.pretty(indent)}` : ""})`;
+    }
     clone() {
         return new TirFailExpr(this.failMsgExpr?.clone(), this.type.clone(), this.range.clone());
     }

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

@@ -10,11 +10,12 @@ export declare class TirFromDataExpr implements ITirExpr {
     readonly type: TirType;
     readonly range: SourceRange;
     constructor(dataExpr: TirExpr, type: TirType, range: SourceRange);
-    clone(): TirFromDataExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     get isConstant(): boolean;
     deps(): string[];
     toIR(ctx: ToIRTermCtx): IRTerm;
-    toString(): string;
 }
 export declare function _inlineFromData(target_t: TirType, dataExprIR: IRTerm): IRTerm;
 export declare function _fromDataUplcFunc(_target_t: TirType): IRTerm;