@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

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

@@ -1,4 +1,4 @@
-import { IRApp } from "../../../IR/IRNodes/IRApp.js";
+import { _ir_apps, IRApp } from "../../../IR/IRNodes/IRApp.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRConstr } from "../../../IR/IRNodes/IRConstr.js";
 import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
@@ -7,7 +7,6 @@ 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_apps } from "../../../IR/tree_utils/_ir_apps.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";
@@ -33,6 +32,14 @@ export class TirFromDataExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `fromData<${this.type.toString()}>(${this.dataExpr.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `fromData<${this.type.toString()}>(${this.dataExpr.pretty(indent)})`;
+    }
     clone() {
         return new TirFromDataExpr(this.dataExpr.clone(), this.type.clone(), this.range.clone());
     }
@@ -43,9 +50,6 @@ export class TirFromDataExpr {
     toIR(ctx) {
         return _inlineFromData(this.type, this.dataExpr.toIR(ctx));
     }
-    toString() {
-        return `fromData(${this.dataExpr.toString()}) as ${this.type.toString()}`;
-    }
 }
 export function _inlineFromData(target_t, dataExprIR) {
     const to_t = getUnaliased(target_t);
@@ -74,11 +78,11 @@ export function _inlineFromData(target_t, dataExprIR) {
         if (!isTirType(value_t))
             throw new Error("TirFromDataExpr: unreachable");
         return _ir_let(// introuduce a var
-        _ir_apps(IRNative.unConstrData, dataExprIR), _ir_apps(IRNative.strictIfThenElse, _ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
+        _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(0) // unConstrData result
+            _ir_apps(_fromDataUplcFunc(value_t), _ir_apps(IRNative.headList, _ir_apps(IRNative.sndPair, new IRVar(unConstrDataResultSym) // unConstrData result
             )))
         ]), 
         // else (Nothing)
@@ -101,11 +105,11 @@ export function _fromDataUplcFunc(_target_t) {
     if (target_t instanceof TirBytesT)
         return IRNative.unBData;
     if (target_t instanceof TirVoidT)
-        return _mkUnit;
+        return _mkUnit.clone();
     if (target_t instanceof TirBoolT)
-        return _boolFromData;
+        return _boolFromData.clone();
     if (target_t instanceof TirStringT)
-        return _strFromData;
+        return _strFromData.clone();
     if (target_t instanceof TirLinearMapT)
         // linear maps only have pairs as elements
         // and we only support pairs of data (bc we only have `mkPairData`)
@@ -116,23 +120,23 @@ export function _fromDataUplcFunc(_target_t) {
             || elems_t instanceof TirDataOptT
             || elems_t instanceof TirDataT)
             return IRNative.unListData;
-        return new IRHoisted(new IRFunc(1, // data ( representing list )
-        _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _fromDataUplcFunc(elems_t), _ir_apps(IRNative.unListData, new IRVar(0) // data
-        ))));
+        return mkMapListFromData(elems_t);
     }
     if (target_t instanceof TirSopOptT
         || target_t instanceof TirSoPStructType) {
-        return new IRHoisted(new IRFunc(1, // data
-        _inlineFromData(target_t, new IRVar(0) // data
-        )));
+        return mkSopFromData(target_t);
     }
     throw new Error(`TirFromDataExpr: cannot convert from Data to type ${target_t.toString()}`);
 }
-const _mkUnit = new IRHoisted(new IRFunc(1, IRConst.unit, "~_mkUnit"));
-const _boolFromData = new IRHoisted(new IRFunc(1, _ir_apps(IRNative.equalsInteger, new IRApp(IRNative.fstPair, new IRApp(IRNative.unConstrData, new IRVar(0))), IRConst.int(0))));
-const _strFromData = new IRHoisted(new IRFunc(1, // data
-_ir_apps(IRNative.decodeUtf8, _ir_apps(IRNative.unBData, new IRVar(0) // data
-))));
+// replace old numeric-arity helpers
+const _unitFromDataSym = Symbol("unit");
+const _mkUnit = new IRHoisted(new IRFunc([_unitFromDataSym], IRConst.unit));
+const _boolFromDataDataSym = Symbol("boolData");
+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))));
+const _strFromDataDataSym = Symbol("strData");
+const _strFromData = new IRHoisted(new IRFunc([_strFromDataDataSym], // data
+_ir_apps(IRNative.decodeUtf8, _ir_apps(IRNative.unBData, new IRVar(_strFromDataDataSym)))));
 export function _inilneSingeSopConstrFromData(sop_t, dataExprIR) {
     if (sop_t.constructors.length !== 1)
         throw new Error("_inilneSingeSopConstrFromData: multiple constructors");
@@ -149,48 +153,73 @@ export function _inilneSingeSopConstrFromData(sop_t, dataExprIR) {
             _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)), // introuduce fields list
-    new IRConstr(0, constr.fields.map((field, i) => {
+    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(0) // fields list
-            : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(0) // fields list
-            )));
+        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);
-    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(0) // fields list
-                ))
-            ]);
+    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)));
         }
-        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(0) // fields list
-                : _ir_apps(IRNative._dropList, IRConst.int(i), new IRVar(0) // fields list
-                )));
-        }));
-    });
-    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(1), // isConstrIdx
-        IRConst.int(i)), new IRDelayed(continuations[i]), new IRDelayed(finalIfThenElseChain)));
-    }
-    return _ir_let(_ir_apps(IRNative.unConstrData, dataExprIR), // unConstrData result
-    _ir_let(_ir_apps(IRNative.equalsInteger, _ir_apps(IRNative.fstPair, new IRVar(0) // unConstrData result
-    )), // isConstrIdx
-    _ir_let(_ir_apps(IRNative.sndPair, new IRVar(1)), // fields list
-    finalIfThenElseChain)));
+        return finalIfThenElseChain;
+    })));
+}
+// new cached hoisted helpers (mirroring TirToDataExpr pattern)
+const _mapListFromDataOfType = {};
+function mkMapListFromData(elems_t) {
+    const key = elems_t.toTirTypeKey();
+    if (_mapListFromDataOfType[key])
+        return _mapListFromDataOfType[key].clone();
+    const listDataSym = Symbol("mapListFromData_data");
+    _mapListFromDataOfType[key] = new IRHoisted(new IRFunc([listDataSym], // data (list data)
+    _ir_apps(IRNative._mkMapList, IRConst.listOf(elems_t)([]), _fromDataUplcFunc(elems_t), _ir_apps(IRNative.unListData, new IRVar(listDataSym) // data
+    ))));
+    return _mapListFromDataOfType[key].clone();
+}
+const _sopFromDataOfType = {};
+function mkSopFromData(target_t) {
+    const key = target_t.toTirTypeKey();
+    if (_sopFromDataOfType[key])
+        return _sopFromDataOfType[key].clone();
+    const dataSym = Symbol("sop_data");
+    _sopFromDataOfType[key] = new IRHoisted(new IRFunc([dataSym], // data
+    _inlineFromData(target_t, new IRVar(dataSym))));
+    return _sopFromDataOfType[key].clone();
 }

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

@@ -6,6 +6,7 @@ import { TirBlockStmt } from "../statements/TirBlockStmt.js";
 import { ToIRTermCtx } from "./ToIRTermCtx.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
 import { IRTerm } from "../../../IR/IRTerm.js";
+import type { TirExpr } from "./TirExpr.js";
 export declare class TirFuncExpr implements ITirExpr {
     readonly name: string;
     readonly params: TirSimpleVarDecl[];
@@ -16,16 +17,9 @@ export declare class TirFuncExpr implements ITirExpr {
     get type(): TirFuncT;
     sig(): TirFuncT;
     constructor(name: string, params: TirSimpleVarDecl[], returnType: TirType, body: TirBlockStmt, range: SourceRange, _isLoop?: boolean);
-    clone(): TirFuncExpr;
-    /**
-     * `true` if the function is guaranteed to never error
-     */
-    readonly isSafe: boolean;
-    /**
-     * `true` if, for all cases where the function can error,
-     * there is an alternative implementation that is safe (wrapping the result as `Optional`)
-     */
-    readonly isRecoverable: boolean;
+    toString(): string;
+    pretty(indent?: number): string;
+    clone(): TirExpr;
     isAnonymous(): boolean;
     private _deps;
     private _defineDeps;

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

@@ -33,18 +33,34 @@ export class TirFuncExpr {
         this.range = range;
         this._isLoop = _isLoop;
     }
+    toString() {
+        return (`function ${this.name}` +
+            `( ${this.params.map(p => p.toString()).join(", ")} )` +
+            `: ${this.returnType.toString()} ` +
+            `${this.body.toString()}`);
+    }
+    pretty(indent = 1) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        const indent_1 = indent_0 + singleIndent;
+        return (`function ${this.name}(` +
+            indent_1 + this.params.map(p => p.pretty(indent + 1)).join(`,${indent_1}`) +
+            `${indent_0}): ${this.returnType.toString()} ` +
+            this.body.pretty(indent));
+    }
     clone() {
         return new TirFuncExpr(this.name, this.params.slice(), this.returnType.clone(), this.body, this.range.clone(), this._isLoop);
     }
-    /**
-     * `true` if the function is guaranteed to never error
-     */
-    isSafe = false;
-    /**
-     * `true` if, for all cases where the function can error,
-     * there is an alternative implementation that is safe (wrapping the result as `Optional`)
-     */
-    isRecoverable = false;
+    // / **
+    //  * `true` if the function is guaranteed to never error
+    //  * /
+    // readonly isSafe: boolean = false;
+    // / **
+    //  * `true` if, for all cases where the function can error,
+    //  * there is an alternative implementation that is safe (wrapping the result as `Optional`)
+    //  * /
+    // readonly isRecoverable: boolean = false;
     isAnonymous() {
         return this.name === "";
     }
@@ -81,12 +97,13 @@ export class TirFuncExpr {
         const expr = returnStmt.value;
         const isRecursive = this.isRecursive();
         ctx = ctx.newChild();
+        let recursiveVarSym = undefined;
         if (isRecursive)
-            ctx.defineRecursiveVar(this.name);
-        this.params.forEach(param => ctx.defineVar(param.name));
-        let irFunc = new IRFunc(this.params.length, expr.toIR(ctx), this.name);
+            recursiveVarSym = ctx.defineRecursiveVar(this.name);
+        const introuducedVars = this.params.map(param => ctx.defineVar(param.name));
+        let irFunc = new IRFunc(introuducedVars, expr.toIR(ctx));
         if (isRecursive)
-            irFunc = new IRRecursive(irFunc, this.name);
+            irFunc = new IRRecursive(recursiveVarSym, irFunc);
         return irFunc;
     }
 }

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

@@ -10,7 +10,9 @@ export declare class TirHoistedExpr implements ITirExpr {
     get type(): TirType;
     get range(): SourceRange;
     constructor(varName: string, expr: TirExpr);
-    clone(): TirHoistedExpr;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
     deps(): string[];
     unsafeClone(): TirHoistedExpr;
     get isConstant(): boolean;

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

@@ -12,6 +12,14 @@ export class TirHoistedExpr {
         this.varName = varName;
         this.expr = expr;
     }
+    toString() {
+        return `/*hoisted '${this.varName}'*/(${this.expr.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `/*hoisted '${this.varName}'*/(${this.expr.pretty(indent)})`;
+    }
     clone() {
         return new TirHoistedExpr(this.varName, this.expr.clone());
     }

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

@@ -2,6 +2,7 @@ import { SourceRange } from "../../../ast/Source/SourceRange.js";
 import type { IRTerm } from "../../../IR/IRTerm.js";
 import { TirFuncT } from "../types/TirNativeType/index.js";
 import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
 import { ToIRTermCtx } from "./ToIRTermCtx.js";
 export declare class TirInlineClosedIR implements ITirExpr {
     readonly type: TirFuncT;
@@ -9,8 +10,10 @@ export declare class TirInlineClosedIR implements ITirExpr {
     readonly range: SourceRange;
     sig(): TirFuncT;
     constructor(type: TirFuncT, getIr: (ctx: ToIRTermCtx) => IRTerm, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
     get isConstant(): boolean;
-    clone(): ITirExpr;
+    clone(): TirExpr;
     deps(): string[];
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

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

@@ -11,6 +11,14 @@ export class TirInlineClosedIR {
         this.getIr = getIr;
         this.range = range;
     }
+    toString() {
+        return `<closed IR> as ${this.type.toString()}`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `<closed IR> as ${this.type.toString()}`;
+    }
     get isConstant() { return true; }
     clone() {
         return new TirInlineClosedIR(this.type.clone(), this.getIr, this.range.clone());

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

@@ -8,11 +8,14 @@ export declare class TirLettedExpr implements ITirExpr {
     readonly varName: string;
     expr: TirExpr;
     readonly range: SourceRange;
+    private _creationStack;
     get type(): TirType;
-    constructor(varName: string, expr: TirExpr, range: SourceRange);
+    private readonly _irVarSym;
+    constructor(varName: string, expr: TirExpr, range: SourceRange, _unsafeVarSym?: symbol | undefined, _creationStack?: string | undefined);
+    toString(): string;
+    pretty(indent: number): string;
     deps(): string[];
-    clone(): TirLettedExpr;
-    unsafeClone(): TirLettedExpr;
+    clone(): TirExpr;
     get isConstant(): boolean;
     toIR(ctx: ToIRTermCtx): IRTerm;
 }

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

@@ -3,26 +3,39 @@ export class TirLettedExpr {
     varName;
     expr;
     range;
+    _creationStack = undefined;
     get type() {
         return this.expr.type;
     }
-    constructor(varName, expr, range) {
+    _irVarSym;
+    constructor(varName, expr, range, _unsafeVarSym, _creationStack) {
         this.varName = varName;
         this.expr = expr;
         this.range = range;
+        if (!(typeof varName === "string"
+            && varName.length > 0))
+            throw new Error("TirLettedExpr: varName must be a non empty string");
+        this._creationStack = _creationStack ?? (new Error()).stack;
+        this._irVarSym = (typeof _unsafeVarSym === "symbol"
+            && _unsafeVarSym.description === varName) ? _unsafeVarSym : Symbol(varName);
+    }
+    toString() {
+        return `/*letted '${this.varName}'*/(${this.expr.toString()})`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        const indent_0 = "\n" + indent_base;
+        return `/*letted '${this.varName}'*/(${indent_0}${this.expr.pretty(indent)}${indent_0})`;
     }
     deps() {
         return this.expr.deps();
     }
     clone() {
-        return new TirLettedExpr(this.varName, this.expr.clone(), this.range.clone());
-    }
-    unsafeClone() {
-        return new TirLettedExpr(this.varName, this.expr, // this.expr.clone(),
-        this.range);
+        return new TirLettedExpr(this.varName, this.expr.clone(), this.range.clone(), this._irVarSym, this._creationStack);
     }
     get isConstant() { return this.expr.isConstant; }
     toIR(ctx) {
-        return new IRLetted(ctx.dbn, this.expr.toIR(ctx));
+        return new IRLetted(this._irVarSym, this.expr.toIR(ctx));
     }
 }

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

@@ -5,12 +5,16 @@ import type { IRTerm } from "../../../IR/IRTerm.js";
 import { TirType } from "../types/TirType.js";
 import { ToIRTermCtx } from "./ToIRTermCtx.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
+import { TirHoistedExpr } from "./TirHoistedExpr.js";
+import { TirExpr } from "./TirExpr.js";
 export declare class TirNativeFunc implements ITirExpr {
     readonly tag: IRNativeTag;
     readonly type: TirFuncT;
     constructor(tag: IRNativeTag, type: TirFuncT);
+    toString(): string;
+    pretty(indent: number): string;
     toIR(ctx: ToIRTermCtx): IRTerm;
-    clone(): TirNativeFunc;
+    clone(): TirExpr;
     get range(): SourceRange;
     deps(): string[];
     get isConstant(): boolean;
@@ -81,6 +85,7 @@ export declare class TirNativeFunc implements ITirExpr {
     static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _mkFindDataOptional(elems_t: TirType): TirNativeFunc;
+    static _findSopOptional(elems_t: TirType): TirNativeFunc;
     static _length(elemT: TirType): TirNativeFunc;
     static _some(elemT: TirType): TirNativeFunc;
     static _every(elemT: TirType): TirNativeFunc;
@@ -88,9 +93,7 @@ export declare class TirNativeFunc implements ITirExpr {
     static _id(t: TirType): TirNativeFunc;
     static get _not(): TirNativeFunc;
     static get _strictAnd(): TirNativeFunc;
-    static get _and(): TirNativeFunc;
     static get _strictOr(): TirNativeFunc;
-    static get _or(): TirNativeFunc;
     static get _gtBS(): TirNativeFunc;
     static get _gtEqBS(): TirNativeFunc;
     static get _gtInt(): TirNativeFunc;
@@ -98,7 +101,8 @@ export declare class TirNativeFunc implements ITirExpr {
     static get _pairDataToData(): TirNativeFunc;
     static get _pairDataFromData(): TirNativeFunc;
     static _mkEqualsList(elemT: TirType): TirNativeFunc;
-    static get _equalPairData(): TirNativeFunc;
-    static get _equalBoolean(): TirNativeFunc;
+    static get _equalPairData(): TirHoistedExpr;
+    static get _equalBoolean(): TirHoistedExpr;
+    static _equals(t: TirType): TirExpr;
     static get _negateInt(): TirNativeFunc;
 }

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

@@ -2,11 +2,16 @@ import { SourceRange } from "../../../ast/Source/SourceRange.js";
 import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { bool_t, bytes_t, data_t, int_t, void_t } from "../program/stdScope/stdScope.js";
-import { TirUnConstrDataResultT, TirPairDataT } from "../types/TirNativeType/index.js";
+import { TirUnConstrDataResultT, TirPairDataT, TirIntT, TirBytesT, TirDataT, TirBoolT, TirSopOptT } from "../types/TirNativeType/index.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
 import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
 import { TirListT } from "../types/TirNativeType/native/list.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirDataStructType } from "../types/TirStructType.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+import { getListTypeArg } from "../types/utils/getListTypeArg.js";
+import { TirHoistedExpr } from "./TirHoistedExpr.js";
+import { TirCallExpr } from "./TirCallExpr.js";
 export class TirNativeFunc {
     tag;
     type;
@@ -14,6 +19,14 @@ export class TirNativeFunc {
         this.tag = tag;
         this.type = type;
     }
+    toString() {
+        return `<native ${IRNativeTag[this.tag]}>`;
+    }
+    pretty(indent) {
+        const singleIndent = "  ";
+        const indent_base = singleIndent.repeat(indent);
+        return `<native ${IRNativeTag[this.tag]}>`;
+    }
     toIR(ctx) {
         return new IRNative(this.tag);
     }
@@ -660,6 +673,14 @@ export class TirNativeFunc {
             new TirListT(elems_t)
         ], new TirDataOptT(elems_t)));
     }
+    static _findSopOptional(elems_t) {
+        return new TirNativeFunc(IRNativeTag._findSopOptional, new TirFuncT([
+            // predicate: (elemT) => bool
+            new TirFuncT([elems_t], bool_t),
+            // list<elemT>
+            new TirListT(elems_t)
+        ], new TirSopOptT(elems_t)));
+    }
     static _length(elemT) {
         return new TirNativeFunc(IRNativeTag._length, new TirFuncT([
             // list
@@ -668,11 +689,9 @@ export class TirNativeFunc {
     }
     static _some(elemT) {
         return new TirNativeFunc(IRNativeTag._some, new TirFuncT([
-            // predicate
-            new TirFuncT([
-                elemT
-            ], bool_t),
-            // list
+            // predicate ((elemT) => bool)
+            new TirFuncT([elemT], bool_t),
+            // list<elemT>
             new TirListT(elemT)
         ], bool_t));
     }
@@ -713,24 +732,12 @@ export class TirNativeFunc {
             bool_t
         ], bool_t));
     }
-    static get _and() {
-        return new TirNativeFunc(IRNativeTag._and, new TirFuncT([
-            bool_t,
-            bool_t
-        ], bool_t));
-    }
     static get _strictOr() {
         return new TirNativeFunc(IRNativeTag._strictOr, new TirFuncT([
             bool_t,
             bool_t
         ], bool_t));
     }
-    static get _or() {
-        return new TirNativeFunc(IRNativeTag._or, new TirFuncT([
-            bool_t,
-            bool_t
-        ], bool_t));
-    }
     static get _gtBS() {
         return new TirNativeFunc(IRNativeTag._gtBS, new TirFuncT([
             bytes_t,
@@ -781,20 +788,49 @@ export class TirNativeFunc {
         ], bool_t));
     }
     static get _equalPairData() {
-        return new TirNativeFunc(IRNativeTag._equalPairData, new TirFuncT([
+        return new TirHoistedExpr("equal_pair_data", new TirNativeFunc(IRNativeTag._equalPairData, new TirFuncT([
             // pairA
             new TirPairDataT(),
             // pairB
             new TirPairDataT()
-        ], bool_t));
+        ], bool_t)));
     }
     static get _equalBoolean() {
-        return new TirNativeFunc(IRNativeTag._equalBoolean, new TirFuncT([
+        return new TirHoistedExpr("equal_boolean", new TirNativeFunc(IRNativeTag._equalBoolean, new TirFuncT([
             // a
             bool_t,
             // b
             bool_t
-        ], bool_t));
+        ], bool_t)));
+    }
+    static _equals(t) {
+        t = getUnaliased(t);
+        if (t instanceof TirIntT)
+            return this.equalsInteger;
+        if (t instanceof TirBytesT)
+            return this.equalsByteString;
+        if (t instanceof TirPairDataT)
+            return this._equalPairData;
+        if (t instanceof TirBoolT)
+            return this._equalBoolean;
+        if (t instanceof TirDataT
+            || t instanceof TirDataOptT
+            || t instanceof TirDataStructType)
+            return this.equalsData;
+        if (t instanceof TirListT) {
+            const elemT = getListTypeArg(t);
+            if (!elemT)
+                throw new Error(`Could not get element type of list type ${t.toString()}`);
+            const elemName = elemT.toConcreteTirTypeName();
+            const funcName = `equal_list_of_${elemName}`;
+            return new TirHoistedExpr(funcName, new TirCallExpr(this._mkEqualsList(elemT), [this._equals(elemT)], new TirFuncT([
+                // listA
+                new TirListT(elemT),
+                // listB
+                new TirListT(elemT)
+            ], bool_t), SourceRange.unknown));
+        }
+        throw new Error(`No native equals function for type ${t.toString()}`);
     }
     static get _negateInt() {
         return new TirNativeFunc(IRNativeTag._negateInt, new TirFuncT([

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

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

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

@@ -7,6 +7,12 @@ export class TirParentesizedExpr {
         this.type = type;
         this.range = range;
     }
+    toString() {
+        return `(${this.expr.toString()})`;
+    }
+    pretty(indent) {
+        return `(${this.expr.pretty(indent)})`;
+    }
     clone() {
         return new TirParentesizedExpr(this.expr.clone(), this.type.clone(), this.range.clone());
     }