@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../IRTerm.js";
+export declare function rewriteNativesAppliedToConstantsAndReturnRoot(term: IRTerm): IRTerm;

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

@@ -0,0 +1,85 @@
+import { _ir_apps } from "../../IRNodes/IRApp.js";
+import { IRConst } from "../../IRNodes/IRConst.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 { IRVar } from "../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../utils/getApplicationTerms.js";
+import { _compTimeDropN } from "./_comptimeDropN.js";
+export function rewriteNativesAppliedToConstantsAndReturnRoot(term) {
+    // traverse the tree, find applications of natives to constants
+    // and replace them with the optimized equivalent
+    const stack = [term];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        const parent = current.parent;
+        const appTerms = getApplicationTerms(current);
+        if (!appTerms) {
+            stack.unshift(...current.children());
+            continue;
+        }
+        const { func, args } = appTerms;
+        const [fstArg, ...restArgs] = args;
+        if (isId(func)
+            && restArgs.length === 0) {
+            if (parent) {
+                _modifyChildFromTo(parent, current, fstArg);
+            }
+            else {
+                term = fstArg;
+                term.parent = undefined;
+            }
+            stack.unshift(fstArg);
+            continue;
+        }
+        if (!(fstArg instanceof IRConst)) {
+            stack.unshift(...current.children());
+            continue;
+        }
+        if (isDropList(func)
+            && (typeof fstArg.value === "bigint"
+                || typeof fstArg.value === "number")) {
+            const newTerm = restArgs.length >= 1 ? _ir_apps(_compTimeDropN(fstArg.value), ...restArgs) : _compTimeDropN(fstArg.value);
+            if (parent) {
+                _modifyChildFromTo(parent, current, newTerm);
+            }
+            else {
+                term = newTerm;
+                term.parent = undefined;
+            }
+            stack.unshift(newTerm);
+            continue;
+        }
+        // const tsEnsureExhaustiveCheck: never = func;
+        stack.unshift(...current.children());
+    }
+    return term;
+}
+function isDropList(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return (term instanceof IRNative
+        && term.tag === IRNativeTag._dropList);
+}
+function isId(term) {
+    while (term instanceof IRHoisted
+        || term instanceof IRLetted) {
+        if (term instanceof IRHoisted)
+            term = term.hoisted;
+        else if (term instanceof IRLetted)
+            term = term.value;
+    }
+    return ((term instanceof IRNative
+        && term.tag === IRNativeTag._id) || (term instanceof IRFunc
+        && term.params.length === 1
+        && term.body instanceof IRVar
+        && term.body.name === term.params[0]));
+}

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

@@ -81,4 +81,5 @@ export function sanifyTree(ir) {
         }
         return;
     }
+    const tsEnsureExhaustiveCheck = ir;
 }

package/dist/IR/toUPLC/utils/getApplicationTerms.d.ts

@@ -0,0 +1,6 @@
+import { IRTerm } from "../../IRTerm.js";
+export interface ApplicationTerms {
+    func: IRTerm;
+    args: IRTerm[];
+}
+export declare function getApplicationTerms(term: IRTerm): ApplicationTerms | undefined;

package/dist/IR/toUPLC/utils/getApplicationTerms.js

@@ -0,0 +1,37 @@
+import { IRApp } from "../../IRNodes/IRApp.js";
+import { IRCase } from "../../IRNodes/IRCase.js";
+import { IRConstr } from "../../IRNodes/IRConstr.js";
+export function getApplicationTerms(term) {
+    const args = [];
+    while (term instanceof IRApp
+        || (term instanceof IRCase
+            && term.continuations.length === 1
+            && term.constrTerm instanceof IRConstr
+            && Number(term.constrTerm.index) === 0)
+    // go "through" letted and hoisted
+    // || term instanceof IRLetted
+    // || term instanceof IRHoisted
+    ) {
+        if (term instanceof IRApp) {
+            args.unshift(term.arg);
+            term = term.fn;
+            continue;
+        }
+        if (term instanceof IRCase
+            && term.continuations.length === 1
+            && term.constrTerm instanceof IRConstr
+            && Number(term.constrTerm.index) === 0) {
+            args.push(...term.constrTerm.fields);
+            term = term.continuations[0];
+            continue;
+        }
+        // if( term instanceof IRLetted ) term = term.value;
+        // else if( term instanceof IRHoisted ) term = term.hoisted;
+    }
+    if (args.length === 0)
+        return undefined;
+    return {
+        func: term,
+        args,
+    };
+}

package/dist/IR/tree_utils/_ir_lazyChooseList.d.ts

@@ -1,3 +1,3 @@
-import { IRForced } from "../IRNodes/index.js";
-import { IRTerm } from "../IRTerm.js";
+import { IRForced } from "../IRNodes/IRForced.js";
+import type { IRTerm } from "../IRTerm.js";
 export declare function _ir_lazyChooseList(listTerm: IRTerm, caseNil: IRTerm, caseCons: IRTerm): IRForced;

package/dist/IR/tree_utils/_ir_lazyChooseList.js

@@ -1,5 +1,7 @@
-import { IRDelayed, IRForced, IRNative } from "../IRNodes/index.js";
-import { _ir_apps } from "./_ir_apps.js";
+import { _ir_apps } from "../IRNodes/IRApp.js";
+import { IRDelayed } from "../IRNodes/IRDelayed.js";
+import { IRForced } from "../IRNodes/IRForced.js";
+import { IRNative } from "../IRNodes/IRNative/index.js";
 export function _ir_lazyChooseList(listTerm, caseNil, caseCons) {
     return new IRForced(_ir_apps(IRNative.strictChooseList, listTerm, new IRDelayed(caseNil), new IRDelayed(caseCons)));
 }

package/dist/IR/tree_utils/_ir_lazyIfThenElse.d.ts

@@ -1,3 +1,3 @@
-import { IRForced } from "../IRNodes/index.js";
+import { IRForced } from "../IRNodes/IRForced.js";
 import { IRTerm } from "../IRTerm.js";
 export declare function _ir_lazyIfThenElse(condition: IRTerm, thenBranch: IRTerm, elseBranch: IRTerm): IRForced;

package/dist/IR/tree_utils/_ir_lazyIfThenElse.js

@@ -1,5 +1,7 @@
-import { IRDelayed, IRForced, IRNative } from "../IRNodes/index.js";
-import { _ir_apps } from "./_ir_apps.js";
+import { _ir_apps } from "../IRNodes/IRApp.js";
+import { IRDelayed } from "../IRNodes/IRDelayed.js";
+import { IRForced } from "../IRNodes/IRForced.js";
+import { IRNative } from "../IRNodes/IRNative/index.js";
 export function _ir_lazyIfThenElse(condition, thenBranch, elseBranch) {
     return new IRForced(_ir_apps(IRNative.strictIfThenElse, condition, new IRDelayed(thenBranch), new IRDelayed(elseBranch)));
 }

package/dist/IR/tree_utils/_ir_let.d.ts

@@ -1,3 +1,4 @@
 import { IRApp } from "../IRNodes/index.js";
 import { IRTerm } from "../IRTerm.js";
-export declare function _ir_let(value: IRTerm, body: IRTerm): IRApp;
+export declare function _ir_let(value: IRTerm, mkBody: (varName: symbol) => IRTerm): IRApp;
+export declare function _ir_let_sym(sym: symbol, value: IRTerm, body: IRTerm): IRApp;

package/dist/IR/tree_utils/_ir_let.js

@@ -1,4 +1,8 @@
 import { IRApp, IRFunc } from "../IRNodes/index.js";
-export function _ir_let(value, body) {
-    return new IRApp(new IRFunc(1, body), value);
+export function _ir_let(value, mkBody) {
+    const name = Symbol("lettedVar");
+    return new IRApp(new IRFunc([name], mkBody(name)), value);
+}
+export function _ir_let_sym(sym, value, body) {
+    return new IRApp(new IRFunc([sym], body), value);
 }

package/dist/IR/utils/isClosedIRTerm.d.ts

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

package/dist/IR/utils/isClosedIRTerm.js

@@ -2,7 +2,6 @@ import { IRConst } from "../IRNodes/IRConst.js";
 import { IRFunc } from "../IRNodes/IRFunc.js";
 import { IRApp } from "../IRNodes/IRApp.js";
 import { IRError } from "../IRNodes/IRError.js";
-import { IRNative } from "../IRNodes/IRNative/index.js";
 import { IRHoisted } from "../IRNodes/IRHoisted.js";
 import { IRLetted } from "../IRNodes/IRLetted.js";
 import { IRVar } from "../IRNodes/IRVar.js";
@@ -12,29 +11,33 @@ import { IRConstr } from "../IRNodes/IRConstr.js";
 import { IRCase } from "../IRNodes/IRCase.js";
 import { IRRecursive } from "../IRNodes/IRRecursive.js";
 import { IRSelfCall } from "../IRNodes/IRSelfCall.js";
-function _isClosedIRTerm(term, dbn, parent) {
-    if (term instanceof IRVar) {
-        return term.dbn < dbn;
-    }
-    if (term instanceof IRSelfCall) {
-        return term.dbn < dbn;
-    }
+import { IRNative } from "../IRNodes/IRNative/index.js";
+import { getUnboundedIRVars } from "../toUPLC/subRoutines/handleLetted/groupByScope.js";
+import { prettyIRInline } from "./showIR.js";
+function _isClosedIRTerm(term, boundedVars, parent) {
+    if (term instanceof IRVar)
+        return boundedVars.has(term.name);
+    if (term instanceof IRSelfCall)
+        return boundedVars.has(term.name);
     if (term instanceof IRFunc) {
-        return _isClosedIRTerm(term.body, dbn + term.arity, term);
+        boundedVars = new Set(boundedVars);
+        for (const param of term.params)
+            boundedVars.add(param);
+        return _isClosedIRTerm(term.body, boundedVars, term);
     }
     if (term instanceof IRRecursive) {
-        return _isClosedIRTerm(term.body, dbn + term.arity, term);
-    }
-    if (term instanceof IRApp) {
-        return _isClosedIRTerm(term.fn, dbn, term) && _isClosedIRTerm(term.arg, dbn, term);
-    }
-    if (term instanceof IRConstr) {
-        return Array.from(term.fields).every(f => _isClosedIRTerm(f, dbn, term));
-    }
-    if (term instanceof IRCase) {
-        return _isClosedIRTerm(term.constrTerm, dbn, term) &&
-            Array.from(term.continuations).every(cont => _isClosedIRTerm(cont, dbn, term));
+        boundedVars = new Set(boundedVars);
+        boundedVars.add(term.name);
+        return _isClosedIRTerm(term.body, boundedVars, term);
     }
+    if (term instanceof IRApp)
+        return _isClosedIRTerm(term.fn, boundedVars, term) && _isClosedIRTerm(term.arg, boundedVars, term);
+    if (term instanceof IRConstr)
+        return Array.from(term.fields).every(f => _isClosedIRTerm(f, boundedVars, term));
+    if (term instanceof IRCase)
+        return (_isClosedIRTerm(term.constrTerm, boundedVars, term)
+            && Array.from(term.continuations)
+                .every(cont => _isClosedIRTerm(cont, boundedVars, term)));
     if (term instanceof IRConst)
         return true;
     if (term instanceof IRError)
@@ -42,17 +45,28 @@ function _isClosedIRTerm(term, dbn, parent) {
     if (term instanceof IRNative)
         return true;
     if (term instanceof IRHoisted)
-        return true;
+        return _isClosedIRTerm(term.hoisted, boundedVars, term);
     if (term instanceof IRLetted)
-        return _isClosedIRTerm(term.value, dbn, term);
+        return _isClosedIRTerm(term.value, boundedVars, term);
     if (term instanceof IRForced)
-        return _isClosedIRTerm(term.forced, dbn, term);
+        return _isClosedIRTerm(term.forced, boundedVars, term);
     if (term instanceof IRDelayed)
-        return _isClosedIRTerm(term.delayed, dbn, term);
+        return _isClosedIRTerm(term.delayed, boundedVars, term);
+    const tsEnsureExhaustiveCheck = term;
     // not even an IRTerm
-    console.log(parent);
+    console.error(parent);
     throw new Error("`isClosedIRTerm` called on non-IR argument");
 }
 export function isClosedIRTerm(term) {
-    return _isClosedIRTerm(term, 0);
+    return _isClosedIRTerm(term, new Set(), undefined);
+}
+export function _debug_assertClosedIR(term) {
+    if (!isClosedIRTerm(term)) {
+        const unboundedVars = getUnboundedIRVars(term);
+        console.error("unbounded vars:", unboundedVars.map(variab => variab.name));
+        console.error("term:", prettyIRInline(term));
+        console.error("unbounded parents:", unboundedVars.map(variab => prettyIRInline(variab.parent ?? variab)));
+        console.error("unbounded parents:", unboundedVars.map(variab => variab._creationStack));
+        throw new Error("Term is not closed");
+    }
 }

package/dist/IR/utils/positiveIntAsBytes.d.ts

@@ -3,3 +3,4 @@
  */
 export declare function positiveIntAsBytes(n: number | bigint): Uint8Array;
 export declare function positiveBigIntAsBytes(n: bigint): Uint8Array;
+export declare function zigzagBigintAsBytes(n: bigint): Uint8Array;

package/dist/IR/utils/positiveIntAsBytes.js

@@ -1,4 +1,5 @@
 import { fromHex } from "@harmoniclabs/uint8array-utils";
+import UPLCFlatUtils from "../../utils/UPLCFlatUtils/index.js";
 /**
  * writes the number in a new `Uint8Array` Big Endian
  */
@@ -7,8 +8,6 @@ export function positiveIntAsBytes(n) {
         return positiveBigIntAsBytes(n);
     }
     if (!Number.isSafeInteger(n) || n < 0) {
-        console.log(n);
-        console.trace(); // some help
         throw new Error("how did you end up here? the name of the function explicitly says 'positiveIntAsBytes'");
     }
     let str = n.toString(16);
@@ -17,11 +16,12 @@ export function positiveIntAsBytes(n) {
 }
 export function positiveBigIntAsBytes(n) {
     if (n < 0 || typeof n !== "bigint") {
-        console.log(n);
-        console.trace(); // some help
         throw new Error("how did you end up here? the name of the function explicitly says 'positiveBigIntAsBytes'");
     }
     let strHex = n.toString(16);
     strHex = strHex.length % 2 === 0 ? strHex : "0" + strHex;
     return fromHex(strHex);
 }
+export function zigzagBigintAsBytes(n) {
+    return positiveBigIntAsBytes(UPLCFlatUtils.zigzagBigint(BigInt(n)));
+}

package/dist/IR/utils/showIR.d.ts

@@ -3,33 +3,20 @@ import { IRTerm } from "../IRTerm.js";
 import { IRHoisted } from "../IRNodes/IRHoisted.js";
 import { IRConst } from "../IRNodes/IRConst.js";
 export declare function showIRText(_ir: IRTerm): string;
-export declare function showIR(_ir: IRTerm): {
-    text: string;
-    letted: {
-        [hash: string]: string;
-    };
-    hoisted: {
-        [hash: string]: string;
-    };
-};
-export declare function prettyIRText(_ir: IRTerm, _indent?: number): string | {
-    text: string;
-    letted: {
-        [hash: string]: string;
-    };
-    hoisted: {
-        [hash: string]: string;
-    };
-};
-export type PrettiedIR = {
+export declare function showIR(_ir: IRTerm): PrettiedIR;
+export declare function prettyIRText(_ir: IRTerm, _indent?: number): string;
+export interface PrettiedIR extends HoistedAndLetted {
     text: string;
+}
+export type PrettiedLetted = string;
+export interface HoistedAndLetted {
     letted: {
-        [hash: string]: string;
+        [hash: string]: PrettiedLetted;
     };
     hoisted: {
         [hash: string]: string;
     };
-};
+}
 export declare function prettyIR(_ir: IRTerm, _indent?: number): PrettiedIR;
 export interface PrettyIRJsonStrOpts {
     text: boolean;
@@ -41,3 +28,5 @@ export declare function hoistedToStr(ir: IRHoisted): string;
 export declare function lettedToStr(ir: IRLetted): string;
 export declare function constToString(ir: IRConst): string;
 export declare function prettyIRInline(_ir: IRTerm, _indent?: number): string;
+export declare function unfromatStr(str: string): string;
+export declare function onlyHoistedAndLetted(prettied: PrettiedIR): HoistedAndLetted;

package/dist/IR/utils/showIR.js

@@ -42,9 +42,9 @@ export function showIRText(_ir) {
             return hoistedToStr(ir);
         }
         if (ir instanceof IRVar)
-            return getVarNameForDbn(dbn - 1 - ir.dbn);
+            return ir.name.description;
         if (ir instanceof IRSelfCall)
-            return "self_" + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return "self_" + ir.name.description;
         if (ir instanceof IRConst)
             return constToString(ir);
         if (ir instanceof IRDelayed)
@@ -54,11 +54,9 @@ export function showIRText(_ir) {
         if (ir instanceof IRError)
             return "(error)";
         if (ir instanceof IRFunc) {
-            let vars = new Array(ir.arity);
-            for (let i = 0; i < ir.arity; i++) {
-                vars[i] = getVarNameForDbn(dbn++);
-            }
-            return `(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${vars.join(" ")} ${_loop(ir.body, dbn)})`;
+            const syms = ir.params;
+            const names = syms.map(s => s.description);
+            return `(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${names.join(" ")} ${_loop(ir.body, dbn + names.length)})`;
         }
         if (ir instanceof IRRecursive) {
             const varName = "self_" + getVarNameForDbn(dbn++);
@@ -78,13 +76,8 @@ export function showIR(_ir) {
             for (let i = 0; i < deps.length; i++) {
                 addHoisted(deps[i].hoisted);
             }
-            hoistedHashes.push(hash.slice());
-            Object.defineProperty(hoisted, irHashToHex(hash), {
-                value: showIRText(h.hoisted),
-                writable: false,
-                enumerable: true,
-                configurable: false
-            });
+            hoistedHashes.push(hash);
+            hoisted[irHashToHex(hash)] = prettyIRText(h.hoisted);
         }
     }
     const lettedHashes = [];
@@ -97,14 +90,9 @@ export function showIR(_ir) {
             for (let i = 0; i < nDeps; i++) {
                 addLetted(deps[i].letted);
             }
-            lettedHashes.push(hash.slice());
+            lettedHashes.push(hash);
             getHoistedTerms(l.value).forEach(({ hoisted }) => addHoisted(hoisted));
-            Object.defineProperty(letted, irHashToHex(hash), {
-                value: showIRText(l.value),
-                writable: false,
-                enumerable: true,
-                configurable: false
-            });
+            letted[irHashToHex(hash)] = showIRText(l.value);
         }
     }
     function _loop(ir, dbn) {
@@ -125,9 +113,9 @@ export function showIR(_ir) {
             return hoistedToStr(ir);
         }
         if (ir instanceof IRVar)
-            return getVarNameForDbn(dbn - 1 - ir.dbn);
+            return ir.name.description;
         if (ir instanceof IRSelfCall)
-            return "self_" + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return "self_" + ir.name.description;
         if (ir instanceof IRConst)
             return constToString(ir);
         if (ir instanceof IRDelayed)
@@ -137,11 +125,9 @@ export function showIR(_ir) {
         if (ir instanceof IRError)
             return "(error)";
         if (ir instanceof IRFunc) {
-            let vars = new Array(ir.arity);
-            for (let i = 0; i < ir.arity; i++) {
-                vars[i] = getVarNameForDbn(dbn++);
-            }
-            return `(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${vars.join(" ")} ${_loop(ir.body, dbn)})`;
+            const syms = ir.params;
+            const names = syms.map(s => s.description);
+            return `(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${names.join(" ")} ${_loop(ir.body, dbn + names.length)})`;
         }
         if (ir instanceof IRRecursive) {
             const varName = "self_" + getVarNameForDbn(dbn++);
@@ -158,7 +144,7 @@ export function showIR(_ir) {
 }
 export function prettyIRText(_ir, _indent = 2) {
     if (!Number.isSafeInteger(_indent) || _indent < 1)
-        return showIR(_ir);
+        return showIR(_ir).text;
     const indentStr = " ".repeat(_indent);
     function _loop(ir, dbn, depth) {
         const indent = `\n${indentStr.repeat(depth)}`;
@@ -178,9 +164,9 @@ export function prettyIRText(_ir, _indent = 2) {
             return `${indent}${hoistedToStr(ir)}`;
         }
         if (ir instanceof IRVar)
-            return indent + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return indent + ir.name.description;
         if (ir instanceof IRSelfCall)
-            return indent + "self_" + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return indent + "self_" + ir.name.description;
         if (ir instanceof IRConst)
             return `${indent}${constToString(ir)}`;
         if (ir instanceof IRDelayed)
@@ -190,16 +176,15 @@ export function prettyIRText(_ir, _indent = 2) {
         if (ir instanceof IRError)
             return "(error)";
         if (ir instanceof IRFunc) {
-            let vars = new Array(ir.arity);
-            for (let i = 0; i < ir.arity; i++) {
-                vars[i] = getVarNameForDbn(dbn++);
-            }
-            return `${indent}(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${vars.join(" ")} ${_loop(ir.body, dbn, depth + 1)}${indent})`;
+            const syms = ir.params;
+            const names = syms.map(s => s.description);
+            return `${indent}(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${names.join(" ")} ${_loop(ir.body, dbn + names.length, depth + 1)}${indent})`;
         }
         if (ir instanceof IRRecursive) {
             const varName = "self_" + getVarNameForDbn(dbn++);
             return `${indent}(recursive ${varName} ${_loop(ir.body, dbn, depth + 1)}${indent})`;
         }
+        const tsEnsureExhaustiveCheck = ir;
         return "";
     }
     return _loop(_ir, 0, 0);
@@ -217,9 +202,8 @@ export function prettyIR(_ir, _indent = 2) {
             for (let i = 0; i < deps.length; i++) {
                 addHoisted(deps[i].hoisted);
             }
-            hoistedHashes.push(hash.slice());
-            const hashStr = irHashToHex(hash);
-            Object.defineProperty(hoisted, hashStr, { value: prettyIRText(h.hoisted, _indent), writable: true, enumerable: true });
+            hoistedHashes.push(hash);
+            hoisted[irHashToHex(hash)] = prettyIRText(h.hoisted, _indent);
         }
     }
     const lettedHashes = [];
@@ -232,14 +216,10 @@ export function prettyIR(_ir, _indent = 2) {
             for (let i = 0; i < nDeps; i++) {
                 addLetted(deps[i].letted);
             }
-            lettedHashes.push(hash.slice());
+            lettedHashes.push(hash);
             getHoistedTerms(l.value).forEach(({ hoisted }) => addHoisted(hoisted));
             const hashStr = irHashToHex(hash);
-            Object.defineProperty(letted, hashStr, {
-                value: prettyIRText(l.value, _indent),
-                writable: true,
-                enumerable: true
-            });
+            letted[hashStr] = prettyIRText(l.value, _indent);
         }
     }
     function _loop(ir, dbn, depth) {
@@ -257,9 +237,9 @@ export function prettyIR(_ir, _indent = 2) {
             return `${indent}${hoistedToStr(ir)}`;
         }
         if (ir instanceof IRVar)
-            return indent + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return indent + ir.name.description;
         if (ir instanceof IRSelfCall)
-            return indent + "self_" + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return indent + "self_" + ir.name.description;
         if (ir instanceof IRConst)
             return `${indent}${constToString(ir)}`;
         if (ir instanceof IRDelayed)
@@ -269,17 +249,21 @@ export function prettyIR(_ir, _indent = 2) {
         if (ir instanceof IRError)
             return "(error)";
         if (ir instanceof IRFunc) {
-            let vars = new Array(ir.arity);
-            for (let i = 0; i < ir.arity; i++) {
-                vars[i] = getVarNameForDbn(dbn++);
-            }
-            return `${indent}(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${vars.join(" ")} ${_loop(ir.body, dbn, depth + 1)}${indent})`;
+            const syms = ir.params;
+            const names = syms.map(s => s.description);
+            return `${indent}(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${names.join(" ")} ${_loop(ir.body, dbn + names.length, depth + 1)}${indent})`;
         }
         if (ir instanceof IRRecursive) {
             const varName = "self_" + getVarNameForDbn(dbn++);
             return `${indent}(recursive ${varName} ${_loop(ir.body, dbn, depth + 1)}${indent})`;
         }
-        return "";
+        if (ir instanceof IRConstr)
+            return `${indent}(constr ${ir.index.toString()} [${Array.from(ir.fields).map(f => _loop(f, dbn, depth + 1)).join(`, `)}${indent}])`;
+        if (ir instanceof IRCase)
+            return `${indent}(case ${_loop(ir.constrTerm, dbn, depth + 1)} ${indent}[${Array.from(ir.continuations).map(f => _loop(f, dbn, depth + 1)).join(", ")}${indent}])`;
+        const tsEnsureExhaustiveCheck = ir;
+        console.error(ir);
+        throw new Error("unknown IR node found");
     }
     const text = _loop(_ir, 0, 0);
     return {
@@ -316,7 +300,7 @@ export function hoistedToStr(ir) {
     return `(hoisted${(ir.meta.name ? " {" + ir.meta.name + "}" : "")} ${irHashToHex(ir.hash)})`;
 }
 export function lettedToStr(ir) {
-    return `(letted${(ir.meta.name ? " {" + ir.meta.name + "}" : "")} ${ir.dbn} ${irHashToHex(ir.hash)})`;
+    return `(letted ${ir.name.description} ${irHashToHex(ir.hash)})`;
 }
 export function constToString(ir) {
     return `(const ${ir.type.toString()} ${showUPLCConstValue(ir.value)})`;
@@ -331,21 +315,25 @@ export function prettyIRInline(_ir, _indent = 2) {
             return `${indent}(native ${nativeTagToString(ir.tag)})`;
         if (ir instanceof IRLetted) {
             // addLetted( ir );
-            return (`${indent}(letted${(ir.meta.name ? " {" + ir.meta.name + "}" : "")} ${ir.dbn} ${irHashToHex(ir.hash)}` +
-                `${_loop(ir.value, dbn, depth + 1)}` +
+            return (`${indent}(letted ${ir.name.description}` +
+                `${indent + indentStr}{` +
+                `${_loop(ir.value, dbn, depth + 2)}` +
+                `${indent + indentStr}}` +
                 `${indent})`);
         }
         if (ir instanceof IRHoisted) {
             // addHoisted( ir )
             // return `${indent}${hoistedToStr(ir)}`;
             return (`${indent}(hoisted${(ir.meta.name ? " {" + ir.meta.name + "}" : "")} ${irHashToHex(ir.hash)}` +
-                `${_loop(ir.hoisted, dbn, depth + 1)}` +
+                `${indent + indentStr}{` +
+                `${_loop(ir.hoisted, dbn, depth + 2)}` +
+                `${indent + indentStr}}` +
                 `${indent})`);
         }
         if (ir instanceof IRVar)
-            return indent + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return indent + ir.name.description;
         if (ir instanceof IRSelfCall)
-            return indent + "self_" + getVarNameForDbn(dbn - 1 - ir.dbn);
+            return indent + "self_" + ir.name.description;
         if (ir instanceof IRConst)
             return `${indent}${constToString(ir)}`;
         if (ir instanceof IRDelayed)
@@ -355,11 +343,9 @@ export function prettyIRInline(_ir, _indent = 2) {
         if (ir instanceof IRError)
             return "(error)";
         if (ir instanceof IRFunc) {
-            let vars = new Array(ir.arity);
-            for (let i = 0; i < ir.arity; i++) {
-                vars[i] = getVarNameForDbn(dbn++);
-            }
-            return `${indent}(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${vars.join(" ")} ${_loop(ir.body, dbn, depth + 1)}${indent})`;
+            const syms = ir.params;
+            const names = syms.map(s => s.description);
+            return `${indent}(func ${typeof ir.name === "string" ? "{" + ir.name + "}" : ""} ${names.join(" ")} ${_loop(ir.body, dbn + names.length, depth + 1)}${indent})`;
         }
         if (ir instanceof IRRecursive) {
             const varName = "self_" + getVarNameForDbn(dbn++);
@@ -370,3 +356,19 @@ export function prettyIRInline(_ir, _indent = 2) {
     const text = _loop(_ir, 0, 0);
     return text;
 }
+export function unfromatStr(str) {
+    return str
+        .replace("\n", " ")
+        .replace(/\s+/g, " ");
+}
+export function onlyHoistedAndLetted(prettied) {
+    const result = { letted: {}, hoisted: {} };
+    Object.keys(prettied.letted).forEach(k => {
+        const letted = prettied.letted[k];
+        result.letted[k] = unfromatStr(letted);
+    });
+    Object.keys(prettied.hoisted).forEach(k => {
+        result.hoisted[k] = unfromatStr(prettied.hoisted[k]);
+    });
+    return result;
+}