@harmoniclabs/pebble 0.1.10 → 0.2.0

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

@@ -2,7 +2,7 @@ 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, TirIntT, TirBytesT, TirDataT, TirBoolT, TirSopOptT } from "../types/TirNativeType/index.js";
+import { TirUnConstrDataResultT, TirPairDataT, TirIntT, TirBytesT, TirDataT, TirBoolT, TirSopOptT, TirBlsG1T, TirBlsG2T, TirMlResultT } from "../types/TirNativeType/index.js";
 import { TirFuncT } from "../types/TirNativeType/native/function.js";
 import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
 import { TirLinearMapEntryT } from "../types/TirNativeType/native/linearMapEntry.js";
@@ -395,111 +395,58 @@ export class TirNativeFunc {
             bytes_t
         ], bool_t));
     }
-    // BLS12-381 operations
-    /* TODO: add bls supprot
-    get bls12_381_G1_add(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_add,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_neg(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_neg,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_scalarMul(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_scalarMul,
-            new TirFuncT([bytes_t, int_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_equal(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_equal,
-            new TirFuncT([bytes_t, bytes_t], bool_t)
-        );
-    }
-    get bls12_381_G1_hashToGroup(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_hashToGroup,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_compress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_compress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G1_uncompress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G1_uncompress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_add(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_add,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_neg(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_neg,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_scalarMul(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_scalarMul,
-            new TirFuncT([bytes_t, int_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_equal(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_equal,
-            new TirFuncT([bytes_t, bytes_t], bool_t)
-        );
-    }
-    get bls12_381_G2_hashToGroup(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_hashToGroup,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_compress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_compress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_G2_uncompress(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_G2_uncompress,
-            new TirFuncT([bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_millerLoop(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_millerLoop,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_mulMlResult(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_mulMlResult,
-            new TirFuncT([bytes_t, bytes_t], bytes_t)
-        );
-    }
-    get bls12_381_finalVerify(): TirNativeFunc {
-        return new TirNativeFunc(
-            IRNativeTag.bls12_381_finalVerify,
-            new TirFuncT([bytes_t, bytes_t], bool_t)
-        );
-    }
-    //*/
+    // BLS12-381 operations -- now exposed under `std.crypto.bls12_381`
+    static get bls12_381_G1_add() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_add, new TirFuncT([new TirBlsG1T(), new TirBlsG1T()], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_neg() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_neg, new TirFuncT([new TirBlsG1T()], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_scalarMul() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_scalarMul, new TirFuncT([int_t, new TirBlsG1T()], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_equal() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_equal, new TirFuncT([new TirBlsG1T(), new TirBlsG1T()], bool_t));
+    }
+    static get bls12_381_G1_hashToGroup() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_hashToGroup, new TirFuncT([bytes_t, bytes_t], new TirBlsG1T()));
+    }
+    static get bls12_381_G1_compress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_compress, new TirFuncT([new TirBlsG1T()], bytes_t));
+    }
+    static get bls12_381_G1_uncompress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G1_uncompress, new TirFuncT([bytes_t], new TirBlsG1T()));
+    }
+    static get bls12_381_G2_add() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_add, new TirFuncT([new TirBlsG2T(), new TirBlsG2T()], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_neg() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_neg, new TirFuncT([new TirBlsG2T()], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_scalarMul() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_scalarMul, new TirFuncT([int_t, new TirBlsG2T()], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_equal() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_equal, new TirFuncT([new TirBlsG2T(), new TirBlsG2T()], bool_t));
+    }
+    static get bls12_381_G2_hashToGroup() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_hashToGroup, new TirFuncT([bytes_t, bytes_t], new TirBlsG2T()));
+    }
+    static get bls12_381_G2_compress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_compress, new TirFuncT([new TirBlsG2T()], bytes_t));
+    }
+    static get bls12_381_G2_uncompress() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_G2_uncompress, new TirFuncT([bytes_t], new TirBlsG2T()));
+    }
+    static get bls12_381_millerLoop() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_millerLoop, new TirFuncT([new TirBlsG1T(), new TirBlsG2T()], new TirMlResultT()));
+    }
+    static get bls12_381_mulMlResult() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_mulMlResult, new TirFuncT([new TirMlResultT(), new TirMlResultT()], new TirMlResultT()));
+    }
+    static get bls12_381_finalVerify() {
+        return new TirNativeFunc(IRNativeTag.bls12_381_finalVerify, new TirFuncT([new TirMlResultT(), new TirMlResultT()], bool_t));
+    }
     // Additional hashing functions
     static get keccak_256() {
         return new TirNativeFunc(IRNativeTag.keccak_256, new TirFuncT([

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

@@ -0,0 +1,52 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import { IRTerm } from "../../../IR/IRTerm.js";
+import { TirType } from "../types/TirType.js";
+import { ITirExpr } from "./ITirExpr.js";
+import { TirExpr } from "./TirExpr.js";
+import { ToIRTermCtx } from "./ToIRTermCtx.js";
+/**
+ * `_showIR`-backed compile-time-dispatched show expression.
+ *
+ * Created when the user writes `expr.show()` on a built-in type whose Show
+ * impl the compiler provides (int, bytes, bool, data, void, string,
+ * List<T>, LinearMap<K,V>, data-encoded structs). For user-declared
+ * `type X implements Show { show(self): bytes { ... } }` impls the
+ * regular method-dispatch path in `expressifyVars` keeps applying — this
+ * expr is only emitted when no user impl is registered.
+ */
+export declare class TirShowExpr implements ITirExpr {
+    readonly inner: TirExpr;
+    readonly range: SourceRange;
+    constructor(inner: TirExpr, range: SourceRange);
+    get type(): TirType;
+    get isConstant(): boolean;
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
+    deps(): string[];
+    toIR(ctx: ToIRTermCtx): IRTerm;
+}
+/**
+ * Inline an `IRTerm` of type `t` into its UTF-8 textual representation
+ * (also bytes). Returns the IR producing the show-encoded bytes.
+ *
+ * Mirrors `_inlineToData` — fully compile-time-dispatched per source type:
+ *
+ *   int          -> hoisted_intToUtf8Bytes (decimal, sign-aware)
+ *   bytes        -> hoisted_bytesToHex (lowercase hex)
+ *   bool         -> "true" / "false" via lazy ifThenElse
+ *   data         -> serialiseData -> bytesToHex
+ *   void         -> "()"
+ *   string       -> encodeUtf8 (treat as already-readable text)
+ *   List<T>      -> "[" + intercalate(", ", map(_showIR(T), elems)) + "]"
+ *   LinearMap<K,V> -> "{" + intercalate(", ", map((k,v) -> showK(k) ++ ": " ++ showV(v), entries)) + "}"
+ *
+ * For struct-typed receivers (TirDataStructType / TirSoPStructType) this
+ * function does not produce IR — those should reach a user-declared
+ * `type X implements Show { show(self): bytes { ... } }` and dispatch
+ * through the regular method-call path. The caller is expected to detect
+ * that case before invoking `_showIR`.
+ */
+export declare function _showIR(origin_t: TirType, exprIR: IRTerm): IRTerm;
+/** A canonical 1-arg `(T) -> bytes` IR closure for use as a `Show` dictionary entry. */
+export declare function _showUplcFunc(origin_t: TirType): IRTerm;

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

@@ -0,0 +1,199 @@
+import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IR/IRNodes/IRHoisted.js";
+import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
+import { IRRecursive } from "../../../IR/IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../../../IR/IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IR/IRNodes/IRVar.js";
+import { hoisted_bytesToHex } from "../../../IR/tree_utils/bytesToHex.js";
+import { hoisted_intToUtf8Bytes } from "../../../IR/tree_utils/intToUtf8Bytes.js";
+import { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
+import { fromUtf8 } from "@harmoniclabs/uint8array-utils";
+import { bytes_t } from "../program/stdScope/stdScope.js";
+import { TirDataStructType } from "../types/TirStructType.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";
+import { TirIntT } from "../types/TirNativeType/native/int.js";
+import { TirLinearMapT } from "../types/TirNativeType/native/linearMap.js";
+import { TirListT } from "../types/TirNativeType/native/list.js";
+import { TirStringT } from "../types/TirNativeType/native/string.js";
+import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
+import { TirVoidT } from "../types/TirNativeType/native/void.js";
+import { getListTypeArg } from "../types/utils/getListTypeArg.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+/**
+ * `_showIR`-backed compile-time-dispatched show expression.
+ *
+ * Created when the user writes `expr.show()` on a built-in type whose Show
+ * impl the compiler provides (int, bytes, bool, data, void, string,
+ * List<T>, LinearMap<K,V>, data-encoded structs). For user-declared
+ * `type X implements Show { show(self): bytes { ... } }` impls the
+ * regular method-dispatch path in `expressifyVars` keeps applying — this
+ * expr is only emitted when no user impl is registered.
+ */
+export class TirShowExpr {
+    inner;
+    range;
+    constructor(inner, range) {
+        this.inner = inner;
+        this.range = range;
+    }
+    get type() { return bytes_t; }
+    get isConstant() { return this.inner.isConstant; }
+    toString() { return `show( ${this.inner.toString()} )`; }
+    pretty(indent) {
+        return `show( ${this.inner.pretty(indent)} )`;
+    }
+    clone() {
+        return new TirShowExpr(this.inner.clone(), this.range.clone());
+    }
+    deps() { return this.inner.deps(); }
+    toIR(ctx) {
+        return _showIR(this.inner.type, this.inner.toIR(ctx));
+    }
+}
+/**
+ * Inline an `IRTerm` of type `t` into its UTF-8 textual representation
+ * (also bytes). Returns the IR producing the show-encoded bytes.
+ *
+ * Mirrors `_inlineToData` — fully compile-time-dispatched per source type:
+ *
+ *   int          -> hoisted_intToUtf8Bytes (decimal, sign-aware)
+ *   bytes        -> hoisted_bytesToHex (lowercase hex)
+ *   bool         -> "true" / "false" via lazy ifThenElse
+ *   data         -> serialiseData -> bytesToHex
+ *   void         -> "()"
+ *   string       -> encodeUtf8 (treat as already-readable text)
+ *   List<T>      -> "[" + intercalate(", ", map(_showIR(T), elems)) + "]"
+ *   LinearMap<K,V> -> "{" + intercalate(", ", map((k,v) -> showK(k) ++ ": " ++ showV(v), entries)) + "}"
+ *
+ * For struct-typed receivers (TirDataStructType / TirSoPStructType) this
+ * function does not produce IR — those should reach a user-declared
+ * `type X implements Show { show(self): bytes { ... } }` and dispatch
+ * through the regular method-call path. The caller is expected to detect
+ * that case before invoking `_showIR`.
+ */
+export function _showIR(origin_t, exprIR) {
+    const t = getUnaliased(origin_t);
+    if (t instanceof TirIntT)
+        return _ir_apps(hoisted_intToUtf8Bytes.clone(), exprIR);
+    if (t instanceof TirBytesT)
+        return _ir_apps(hoisted_bytesToHex.clone(), exprIR);
+    if (t instanceof TirBoolT)
+        return _ir_lazyIfThenElse(exprIR, _hoisted_litBytes("true").clone(), _hoisted_litBytes("false").clone());
+    if (t instanceof TirDataT)
+        return _ir_apps(hoisted_bytesToHex.clone(), _ir_apps(IRNative.serialiseData, exprIR));
+    if (t instanceof TirVoidT)
+        return _hoisted_litBytes("()").clone();
+    if (t instanceof TirStringT)
+        return _ir_apps(IRNative.encodeUtf8, exprIR);
+    if (t instanceof TirListT)
+        return _showListIR(t, exprIR);
+    if (t instanceof TirLinearMapT)
+        return _showLinearMapIR(t, exprIR);
+    // data-encoded structs and Optional<T> auto-show via serialiseData + hex.
+    // Users can override by declaring `type X implements Show { ... }` —
+    // that path is handled before _showIR is reached.
+    if (t instanceof TirDataStructType
+        || t instanceof TirDataOptT)
+        return _ir_apps(hoisted_bytesToHex.clone(), _ir_apps(IRNative.serialiseData, exprIR));
+    throw new Error(`_showIR: no built-in Show impl for type ${origin_t.toString()}; ` +
+        `the type must declare \`type X implements Show { show(self): bytes { ... } }\``);
+}
+// ---- helpers ----
+const _hoistedLits = {};
+function _hoisted_litBytes(s) {
+    let cached = _hoistedLits[s];
+    if (!cached) {
+        cached = new IRHoisted(IRConst.bytes(fromUtf8(s)));
+        cached.hash;
+        _hoistedLits[s] = cached;
+    }
+    return cached;
+}
+// recurses through `_showIR`. Caches per element-type to avoid repeated
+// IR construction across multiple call sites for the same `List<T>`.
+const _listShowCache = new Map();
+function _showListIR(listT, exprIR) {
+    const elemT = getUnaliased(getListTypeArg(listT));
+    if (!elemT)
+        throw new Error("_showListIR: missing element type");
+    const key = elemT.toConcreteTirTypeName();
+    let hoisted = _listShowCache.get(key);
+    if (!hoisted) {
+        // \xs ->
+        //   "[" ++
+        //   ( recur xs True )
+        //   ++ "]"
+        // recur = fix \self \xs \first ->
+        //   if nullList xs then ""
+        //   else
+        //     let head = headList xs
+        //     let tail = tailList xs
+        //     ( if first then "" else ", " )
+        //     ++ showElem(head)
+        //     ++ self(tail, False)
+        const xsOuter = Symbol("show_list_xs_outer");
+        const recSelf = Symbol("show_list_self");
+        const xs = Symbol("show_list_xs");
+        const first = Symbol("show_list_first");
+        const recur = new IRRecursive(recSelf, new IRFunc([xs, first], _ir_lazyIfThenElse(_ir_apps(IRNative.nullList, new IRVar(xs)), _hoisted_litBytes("").clone(), 
+        // separator + show(head) + recur(tail, false)
+        _ir_apps(IRNative.appendByteString, 
+        // separator
+        _ir_lazyIfThenElse(new IRVar(first), _hoisted_litBytes("").clone(), _hoisted_litBytes(", ").clone()), _ir_apps(IRNative.appendByteString, 
+        // show(head)
+        _showIR(elemT, _ir_apps(IRNative.headList, new IRVar(xs))), 
+        // recur(tail, false)
+        _ir_apps(new IRSelfCall(recSelf), _ir_apps(IRNative.tailList, new IRVar(xs)), IRConst.bool(false)))))));
+        hoisted = new IRHoisted(new IRFunc([xsOuter], _ir_apps(IRNative.appendByteString, _hoisted_litBytes("[").clone(), _ir_apps(IRNative.appendByteString, _ir_apps(recur, new IRVar(xsOuter), IRConst.bool(true)), _hoisted_litBytes("]").clone()))));
+        hoisted.hash;
+        _listShowCache.set(key, hoisted);
+    }
+    return _ir_apps(hoisted.clone(), exprIR);
+}
+const _linearMapShowCache = new Map();
+function _showLinearMapIR(mapT, exprIR) {
+    const keyT = getUnaliased(mapT.keyTypeArg);
+    const valT = getUnaliased(mapT.valTypeArg);
+    const cacheKey = keyT.toConcreteTirTypeName() + "→" + valT.toConcreteTirTypeName();
+    let hoisted = _linearMapShowCache.get(cacheKey);
+    if (!hoisted) {
+        // LinearMap is List<PairData> at the IR level. Iterate similarly to
+        // _showListIR, but on each entry call showK(fst(entry)) ++ ": " ++
+        // showV(snd(entry)). Both sides go through `unBData / unIData / etc.`
+        // implicitly because the Pebble runtime stores keys/values as data.
+        //
+        // For show purposes we treat the entry as an opaque pair-of-data and
+        // recover the value bytes via `_inlineFromData(...)`-like dispatch.
+        // To keep this turn focused, we invoke `_showIR` with `data` and
+        // accept that K/V are shown via their data encoding (compact). A
+        // future polish pass can recover the original K/V types and call
+        // `_showIR(K)` / `_showIR(V)` directly.
+        const xsOuter = Symbol("show_map_outer");
+        const recSelf = Symbol("show_map_self");
+        const xs = Symbol("show_map_xs");
+        const first = Symbol("show_map_first");
+        // key/value extraction at the IR level: an entry is a Pair<Data,Data>;
+        // fst gets the data-encoded key, snd the data-encoded value. We then
+        // just call _showIR(data, ...) on both, which is `serialiseData ++ hex`.
+        const showEntry = (entryIR) => _ir_apps(IRNative.appendByteString, _showIR(/* data */ /* fall back to data show */ 
+        /* Pebble stores K and V as data inside LinearMap */
+        /* see TirLinearMapT.toUplcConstType */
+        /* TirDataT */
+        /* hack: reach the singleton via a fresh instance */
+        new (require("../types/TirNativeType/native/data.js").TirDataT)(), _ir_apps(IRNative.fstPair, entryIR)), _ir_apps(IRNative.appendByteString, _hoisted_litBytes(": ").clone(), _showIR(new (require("../types/TirNativeType/native/data.js").TirDataT)(), _ir_apps(IRNative.sndPair, entryIR))));
+        const recur = new IRRecursive(recSelf, new IRFunc([xs, first], _ir_lazyIfThenElse(_ir_apps(IRNative.nullList, new IRVar(xs)), _hoisted_litBytes("").clone(), _ir_apps(IRNative.appendByteString, _ir_lazyIfThenElse(new IRVar(first), _hoisted_litBytes("").clone(), _hoisted_litBytes(", ").clone()), _ir_apps(IRNative.appendByteString, showEntry(_ir_apps(IRNative.headList, new IRVar(xs))), _ir_apps(new IRSelfCall(recSelf), _ir_apps(IRNative.tailList, new IRVar(xs)), IRConst.bool(false)))))));
+        hoisted = new IRHoisted(new IRFunc([xsOuter], _ir_apps(IRNative.appendByteString, _hoisted_litBytes("{").clone(), _ir_apps(IRNative.appendByteString, _ir_apps(recur, new IRVar(xsOuter), IRConst.bool(true)), _hoisted_litBytes("}").clone()))));
+        hoisted.hash;
+        _linearMapShowCache.set(cacheKey, hoisted);
+    }
+    return _ir_apps(hoisted.clone(), exprIR);
+}
+/** A canonical 1-arg `(T) -> bytes` IR closure for use as a `Show` dictionary entry. */
+export function _showUplcFunc(origin_t) {
+    const xSym = Symbol("show_self");
+    return new IRHoisted(new IRFunc([xSym], _showIR(origin_t, new IRVar(xSym))));
+}

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

@@ -2,10 +2,10 @@ import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
-import { hoisted_intToUtf8Bytes } from "../../../IR/tree_utils/intToUtf8Bytes.js";
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
-import { TirIntT } from "../types/TirNativeType/index.js";
+import { TirBytesT } from "../types/TirNativeType/index.js";
 import { getUnaliased } from "../types/utils/getUnaliased.js";
+import { _showIR } from "./TirShowExpr.js";
 export class TirTraceExpr {
     traceExpr;
     continuation;
@@ -40,13 +40,17 @@ export class TirTraceExpr {
     toIR(ctx) {
         let bytesIR;
         const exprType = getUnaliased(this.traceExpr.type);
-        if (exprType instanceof TirIntT) {
-            // int -> bytes via intToUtf8Bytes
-            bytesIR = _ir_apps(hoisted_intToUtf8Bytes.clone(), this.traceExpr.toIR(ctx));
+        if (exprType instanceof TirBytesT) {
+            // bytes are assumed to already be valid UTF-8 — pass through
+            // unchanged, as documented for the Show interface.
+            bytesIR = this.traceExpr.toIR(ctx);
         }
         else {
-            // assume bytes
-            bytesIR = this.traceExpr.toIR(ctx);
+            // any other type implementing Show: dispatch through `_showIR`,
+            // which uses the per-type compile-time table (int → decimal,
+            // bool → "true"/"false", data → serialiseData+hex, struct →
+            // user impl or auto-derive, list/map → recursive, ...).
+            bytesIR = _showIR(exprType, this.traceExpr.toIR(ctx));
         }
         // Force(trace(msg, Delay(continuation)))
         // Delay prevents the continuation from being evaluated

package/dist/compiler/tir/program/TypedProgram.d.ts

@@ -1,16 +1,85 @@
 import { DiagnosticEmitter } from "../../../diagnostics/DiagnosticEmitter.js";
 import { DiagnosticMessage } from "../../../diagnostics/DiagnosticMessage.js";
+import { FuncExpr } from "../../../ast/nodes/expr/functions/FuncExpr.js";
 import { AstScope } from "../../AstCompiler/scope/AstScope.js";
 import { UidGenerator } from "../../internalVar.js";
 import { TirFuncExpr } from "../expressions/TirFuncExpr.js";
 import { TirInlineClosedIR } from "../expressions/TirInlineClosedIR.js";
 import { TirSimpleVarDecl } from "../statements/TirVarDecl/TirSimpleVarDecl.js";
+import { TirTestStmt } from "../statements/TirTestStmt.js";
+import { TirTypeParam } from "../types/TirTypeParam.js";
 import { TirType } from "../types/TirType.js";
 import { StdTypes } from "./stdScope/StdTypes.js";
 export interface IGenericType {
     arity: number;
     apply: (argsTirNames: string[]) => (TirType | undefined);
 }
+/**
+ * A pending generic function template registered at AST→TIR collection time.
+ *
+ * Two flavors are supported:
+ * - "user" templates wrap a Pebble `function f<T>(...) { body }` AST node.
+ *   `monomorphizeGeneric` instantiates one by re-compiling a clone of the
+ *   AST in a scope where each type-param name aliases its concrete type.
+ * - "native" templates wrap a polymorphic UPLC builtin (e.g. `mkCons<T>`).
+ *   Each instantiation produces a fresh `TirInlineClosedIR` directly; there
+ *   is no AST involved.
+ *
+ * Both flavors share the same monomorphization memoization on
+ * `program.monomorphizationCache`.
+ */
+/**
+ * An interface-constraint on a type parameter of a generic function.
+ * Captured at template-registration time so `monomorphizeGeneric` doesn't
+ * have to re-resolve the interface at each call site.
+ */
+export interface TypeParamConstraint {
+    /** e.g. "ToData" */
+    interfaceName: string;
+    /** method-name -> AstFuncType signature (as registered in `scope.interfaces`) */
+    methods: Map<string, import("../../../ast/nodes/types/AstNativeTypeExpr.js").AstFuncType>;
+}
+export interface BaseGenericTemplate {
+    /** the AST function name (e.g. "id") or the canonical synthetic name (e.g. "mkCons") */
+    astFuncName: string;
+    /** the type-param symbols in declaration order */
+    typeParams: TirTypeParam[];
+    /** the canonical (pre-monomorphization) tir-name registered on the placeholder value */
+    canonicalTirName: string;
+    /** the placeholder TirFuncT (with TirTypeParams) used to type the generic identifier in scope */
+    placeholderFuncType: import("../types/TirNativeType/native/function.js").TirFuncT;
+    /**
+     * One slot per type param, aligned by index with `typeParams`.
+     * `undefined` for unconstrained params.
+     */
+    constraints: (TypeParamConstraint | undefined)[];
+}
+export interface UserGenericTemplate extends BaseGenericTemplate {
+    kind: "user";
+    /** the FuncExpr AST node — cloned and re-compiled per instantiation */
+    astFuncExpr: FuncExpr;
+    /** the lexical scope where this template was declared */
+    definingScope: AstScope;
+}
+export interface NativeGenericTemplate extends BaseGenericTemplate {
+    kind: "native";
+    /** produces a fresh closed-IR for a given type-arg vector */
+    instantiate: (typeArgs: TirType[]) => TirInlineClosedIR;
+}
+export type GenericTemplate = UserGenericTemplate | NativeGenericTemplate;
+/**
+ * Factory for one method of an interface, evaluated against a concrete type
+ * at monomorphization time. Returns the raw `IRTerm` callable as the method
+ * dictionary — a closed IR closure `(self: ConcreteT, ...) -> ReturnT`.
+ *
+ * For the built-in `ToData` interface this is `_toDataUplcFunc(t)` from
+ * `TirToDataExpr.ts` — a hoisted `IRFunc` that converts its argument to data
+ * using the right per-type encoding (iData / bData / inline-struct-encoder / etc).
+ *
+ * Returning `undefined` signals "this type doesn't implement the interface",
+ * which the caller turns into a diagnostic.
+ */
+export type BuiltinInterfaceImplFactory = (concreteType: TirType) => (import("../../../IR/IRTerm.js").IRTerm | undefined);
 /**
  * for now we only care about "executables"
  *
@@ -19,8 +88,40 @@ export interface IGenericType {
 export declare class TypedProgram extends DiagnosticEmitter {
     readonly constants: Map<string, TirSimpleVarDecl>;
     readonly functions: Map<string, TirFuncExpr | TirInlineClosedIR>;
+    /**
+     * Generic function templates awaiting monomorphization. Keyed by the
+     * canonical AST function name (e.g. "id" for `function id<T>(...)`).
+     */
+    readonly genericTemplates: Map<string, GenericTemplate>;
+    /**
+     * Monomorphization memo: `templateName + "$$" + concreteArgs.join("$$")`
+     * → the TIR function name of the previously-compiled instance.
+     */
+    readonly monomorphizationCache: Map<string, string>;
+    /**
+     * Stack of monomorphizations currently in-flight, used to detect
+     * polymorphic recursion (a generic instantiating itself with different
+     * type arguments mid-compile).
+     */
+    readonly monomorphizationInFlight: Set<string>;
+    /**
+     * Built-in interface implementations.
+     *
+     *   builtinInterfaceImpls[interfaceName][methodName] = factory
+     *
+     * The factory, given a concrete TIR type, returns a `TirExpr` callable
+     * as the method's dictionary entry (typed `(self: T, ...) -> ReturnT`).
+     *
+     * Populated by `populateBuiltinInterfaces` for `ToData` and any other
+     * compiler-supplied interface that user types can implicitly satisfy.
+     * User-declared `type Foo implements I { ... }` impls live on the
+     * struct's `methodNamesPtr` instead.
+     */
+    readonly builtinInterfaceImpls: Map<string, Map<string, BuiltinInterfaceImplFactory>>;
     readonly types: Map<string, TirType>;
     private readonly genericTypes;
+    /** Top-level `test name() { ... }` declarations collected from the entry file. */
+    readonly tests: TirTestStmt[];
     /** main */
     contractTirFuncName: string;
     readonly stdTypes: StdTypes;

package/dist/compiler/tir/program/TypedProgram.js

@@ -4,6 +4,8 @@ import { UidGenerator } from "../../internalVar.js";
 import { TirFuncExpr } from "../expressions/TirFuncExpr.js";
 import { isTirType } from "../types/TirType.js";
 import { populatePreludeScope, populateStdScope } from "./stdScope/stdScope.js";
+import { populateStdNamespace } from "./stdScope/populateStdNamespace.js";
+import { populateBuiltinInterfaces } from "./stdScope/populateBuiltinInterfaces.js";
 import { StdTypes } from "./stdScope/StdTypes.js";
 /**
  * for now we only care about "executables"
@@ -13,8 +15,40 @@ import { StdTypes } from "./stdScope/StdTypes.js";
 export class TypedProgram extends DiagnosticEmitter {
     constants;
     functions;
+    /**
+     * Generic function templates awaiting monomorphization. Keyed by the
+     * canonical AST function name (e.g. "id" for `function id<T>(...)`).
+     */
+    genericTemplates = new Map();
+    /**
+     * Monomorphization memo: `templateName + "$$" + concreteArgs.join("$$")`
+     * → the TIR function name of the previously-compiled instance.
+     */
+    monomorphizationCache = new Map();
+    /**
+     * Stack of monomorphizations currently in-flight, used to detect
+     * polymorphic recursion (a generic instantiating itself with different
+     * type arguments mid-compile).
+     */
+    monomorphizationInFlight = new Set();
+    /**
+     * Built-in interface implementations.
+     *
+     *   builtinInterfaceImpls[interfaceName][methodName] = factory
+     *
+     * The factory, given a concrete TIR type, returns a `TirExpr` callable
+     * as the method's dictionary entry (typed `(self: T, ...) -> ReturnT`).
+     *
+     * Populated by `populateBuiltinInterfaces` for `ToData` and any other
+     * compiler-supplied interface that user types can implicitly satisfy.
+     * User-declared `type Foo implements I { ... }` impls live on the
+     * struct's `methodNamesPtr` instead.
+     */
+    builtinInterfaceImpls = new Map();
     types;
     genericTypes;
+    /** Top-level `test name() { ... }` declarations collected from the entry file. */
+    tests;
     /** main */
     contractTirFuncName = "";
     stdTypes;
@@ -32,12 +66,21 @@ export class TypedProgram extends DiagnosticEmitter {
         this.functions = new Map();
         this.types = new Map();
         this.genericTypes = new Map();
+        this.tests = [];
         this.filePrefix = new Map();
         this.stdScope = new AstScope(undefined, this, { isFunctionDeclScope: false, isMethodScope: false });
         populateStdScope(this);
         this.stdTypes = new StdTypes(this);
         this.preludeScope = new AstScope(this.stdScope, this, { isFunctionDeclScope: false, isMethodScope: false });
         populatePreludeScope(this);
+        // Register built-in interfaces (currently: `ToData`) and their
+        // compiler-supplied impl factories. Must precede `populateStdNamespace`
+        // so constrained native templates (`std.linearMap.prepend`) can
+        // reference `ToData` at registration time.
+        populateBuiltinInterfaces(this);
+        // The `std`, `std.crypto`, `std.crypto.bls12_381`, `std.builtins`
+        // namespaces and all their members live on the prelude scope.
+        populateStdNamespace(this);
     }
     registerType(tirType) {
         if (!isTirType(tirType))