@harmoniclabs/pebble 0.1.4 → 0.1.6

package/dist/IR/IRNodes/IRConst.js

@@ -18,6 +18,7 @@ import { TirDataT } from "../../compiler/tir/types/TirNativeType/native/data.js"
 import { TirFuncT } from "../../compiler/tir/types/TirNativeType/native/function.js";
 import { TirIntT } from "../../compiler/tir/types/TirNativeType/native/int.js";
 import { TirLinearMapT } from "../../compiler/tir/types/TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../../compiler/tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../compiler/tir/types/TirNativeType/native/list.js";
 import { TirDataOptT } from "../../compiler/tir/types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../../compiler/tir/types/TirNativeType/native/Optional/sop.js";
@@ -166,6 +167,8 @@ function isValueAssignableToType(value, type) {
         return (Array.isArray(value) &&
             value.every(v => isValueAssignableToType(v, elemsT)));
     }
+    if (type instanceof TirLinearMapEntryT)
+        return isIRConstPair(value);
     const tsEnsureExsaustiveCheck = type;
     return false;
 }
@@ -216,6 +219,7 @@ function serializeIRConstValue(value, type) {
         return dataToCbor(value);
     if (type instanceof TirFuncT
         || type instanceof TirSopOptT
+        || type instanceof TirLinearMapEntryT
         || type instanceof TirSoPStructType
         || type instanceof TirTypeParam)
         throw new Error("invalid uplc const type");
@@ -270,6 +274,8 @@ export function tirTypeToUplcType(t) {
         return constT.listOf(constT.pairOf(constT.data, constT.data));
     if (t instanceof TirUnConstrDataResultT)
         return constT.pairOf(constT.int, constT.listOf(constT.data));
+    if (t instanceof TirLinearMapEntryT)
+        return constT.pairOf(constT.data, constT.data);
     if (t instanceof TirAliasType
         || t instanceof TirFuncT
         || t instanceof TirSopOptT

package/dist/IR/IRNodes/IRNative/index.js

@@ -14,6 +14,7 @@ import { TirBytesT } from "../../../compiler/tir/types/TirNativeType/native/byte
 import { TirDataT } from "../../../compiler/tir/types/TirNativeType/native/data.js";
 import { TirIntT } from "../../../compiler/tir/types/TirNativeType/native/int.js";
 import { TirLinearMapT } from "../../../compiler/tir/types/TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../../../compiler/tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../../compiler/tir/types/TirNativeType/native/list.js";
 import { TirDataOptT } from "../../../compiler/tir/types/TirNativeType/native/Optional/data.js";
 import { TirStringT } from "../../../compiler/tir/types/TirNativeType/native/string.js";
@@ -242,8 +243,8 @@ export class IRNative {
             return IRNative.equalListOf(getListTypeArg(type));
         if (type instanceof TirLinearMapT)
             return IRNative.equalListOf(new TirPairDataT());
-        if (type instanceof TirLinearMapT)
-            return IRNative.equalListOf(new TirPairDataT());
+        if (type instanceof TirLinearMapEntryT)
+            return IRNative._equalPairData;
         if (type instanceof TirUnConstrDataResultT)
             return getEqUnConstr();
         if (type instanceof TirVoidT)

package/dist/compiler/AstCompiler/internal/exprs/_compileElemAccessExpr.d.ts

@@ -1,5 +1,5 @@
 import { ElemAccessExpr } from "../../../../ast/nodes/expr/ElemAccessExpr.js";
-import { TirElemAccessExpr } from "../../../tir/expressions/TirElemAccessExpr.js";
+import { TirExpr } from "../../../tir/expressions/TirExpr.js";
 import { TirType } from "../../../tir/types/TirType.js";
 import { AstCompilationCtx } from "../../AstCompilationCtx.js";
-export declare function _compileElemAccessExpr(ctx: AstCompilationCtx, expr: ElemAccessExpr, typeHint: TirType | undefined): TirElemAccessExpr | undefined;
+export declare function _compileElemAccessExpr(ctx: AstCompilationCtx, expr: ElemAccessExpr, typeHint: TirType | undefined): TirExpr | undefined;

package/dist/compiler/AstCompiler/internal/exprs/_compileElemAccessExpr.js

@@ -1,16 +1,52 @@
 import { DiagnosticCode } from "../../../../diagnostics/diagnosticMessages.generated.js";
+import { TirCallExpr } from "../../../tir/expressions/TirCallExpr.js";
+import { TirCaseExpr, TirCaseMatcher } from "../../../tir/expressions/TirCaseExpr.js";
 import { TirElemAccessExpr } from "../../../tir/expressions/TirElemAccessExpr.js";
+import { TirFailExpr } from "../../../tir/expressions/TirFailExpr.js";
+import { TirNativeFunc } from "../../../tir/expressions/TirNativeFunc.js";
+import { TirToDataExpr } from "../../../tir/expressions/TirToDataExpr.js";
+import { TirVariableAccessExpr } from "../../../tir/expressions/TirVariableAccessExpr.js";
+import { TirNamedDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
+import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirListT } from "../../../tir/types/TirNativeType/native/list.js";
+import { TirSopOptT } from "../../../tir/types/TirNativeType/native/Optional/sop.js";
 import { canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
+import { getLinearMapTypeArgs } from "../../../tir/types/utils/getListTypeArg.js";
 import { getListTypeArg } from "../../../tir/types/utils/getListTypeArg.js";
+import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "./_compileExpr.js";
 export function _compileElemAccessExpr(ctx, expr, typeHint) {
     const int_t = ctx.program.stdTypes.int;
-    const litsTypeHint = typeHint ? new TirListT(typeHint) : undefined;
-    const arrLikeExpr = _compileExpr(ctx, expr.arrLikeExpr, litsTypeHint);
+    const arrLikeExpr = _compileExpr(ctx, expr.arrLikeExpr, undefined);
     if (!arrLikeExpr)
         return undefined;
-    const arrLikeType = arrLikeExpr.type;
+    const arrLikeType = getUnaliased(arrLikeExpr.type);
+    // LinearMap<K,V>: map[key] desugars to map.lookup(key)!
+    const mapTypeArgs = getLinearMapTypeArgs(arrLikeType);
+    if (mapTypeArgs) {
+        const [kT, vT] = mapTypeArgs;
+        const indexExpr = _compileExpr(ctx, expr.indexExpr, kT);
+        if (!indexExpr)
+            return undefined;
+        if (!canAssignTo(indexExpr.type, kT))
+            return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, expr.indexExpr.range, indexExpr.type.toString(), kT.toString());
+        const optType = new TirSopOptT(vT);
+        // _lookupLinearMap expects data-encoded key
+        const keyAsData = new TirToDataExpr(indexExpr, expr.indexExpr.range);
+        const lookupCall = new TirCallExpr(TirNativeFunc._lookupLinearMap(kT, vT), [keyAsData, arrLikeExpr], optType, expr.range);
+        // unwrap: case lookup is Some{ value } => value, None => fail
+        return new TirCaseExpr(lookupCall, [
+            new TirCaseMatcher(new TirNamedDeconstructVarDecl("Some", new Map([
+                ["value", new TirSimpleVarDecl("value", vT, undefined, true, expr.range)]
+            ]), undefined, optType, undefined, true, expr.range), new TirVariableAccessExpr({
+                variableInfos: { name: "value", type: vT, isConstant: true },
+                isDefinedOutsideFuncScope: false,
+            }, expr.range), expr.range),
+            new TirCaseMatcher(new TirNamedDeconstructVarDecl("None", new Map(), undefined, optType, undefined, true, expr.range), new TirFailExpr(undefined, vT, expr.range), expr.range)
+        ], undefined, vT, expr.range);
+    }
+    // List<T>: list[index]
+    const litsTypeHint = typeHint ? new TirListT(typeHint) : undefined;
     const elemsType = getListTypeArg(arrLikeType);
     if (!elemsType)
         return ctx.error(DiagnosticCode.This_expression_cannot_be_indexed, expr.arrLikeExpr.range);

package/dist/compiler/AstCompiler/internal/statements/_compileVarStmt.js

@@ -9,10 +9,12 @@ import { TirSimpleVarDecl } from "../../../tir/statements/TirVarDecl/TirSimpleVa
 import { TirSingleDeconstructVarDecl } from "../../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
 import { TirDataT } from "../../../tir/types/TirNativeType/native/data.js";
 import { isTirOptType } from "../../../tir/types/TirNativeType/native/Optional/isTirOptType.js";
+import { TirLinearMapEntryT } from "../../../tir/types/TirNativeType/native/linearMapEntry.js";
 import { isTirStructType, TirStructConstr, TirStructField } from "../../../tir/types/TirStructType.js";
 import { getNamedDestructableType, getStructType, canAssignTo } from "../../../tir/types/utils/canAssignTo.js";
 import { canCastToData } from "../../../tir/types/utils/canCastTo.js";
 import { getListTypeArg } from "../../../tir/types/utils/getListTypeArg.js";
+import { getUnaliased } from "../../../tir/types/utils/getUnaliased.js";
 import { _compileExpr } from "../exprs/_compileExpr.js";
 import { _compileSopEncodedConcreteType } from "../types/_compileSopEncodedConcreteType.js";
 export function _compileVarStmt(ctx, stmt) {
@@ -105,6 +107,19 @@ export function _compileSingleDeconstructVarDecl(ctx, decl, typeHint) {
     if (!typeAndExpr)
         return undefined;
     const [finalVarType, initExpr, typeAnnotationRange] = typeAndExpr;
+    // LinearMapEntry<K,V> can be destructured as { key, value }
+    const unaliasedVarType = getUnaliased(finalVarType);
+    if (unaliasedVarType instanceof TirLinearMapEntryT) {
+        const virtualConstr = new TirStructConstr("Entry", [
+            new TirStructField("key", unaliasedVarType.keyTypeArg),
+            new TirStructField("value", unaliasedVarType.valTypeArg),
+        ]);
+        const deconstructedFields = _getDeconstructedFields(ctx, decl, virtualConstr);
+        if (!deconstructedFields)
+            return undefined;
+        const [fields, rest, fieldLabelRanges] = deconstructedFields;
+        return new TirSingleDeconstructVarDecl(fields, rest, finalVarType, initExpr, decl.isConst(), decl.range, fieldLabelRanges, typeAnnotationRange);
+    }
     const finalStructType = getStructType(finalVarType);
     if (!finalStructType)
         return ctx.error(DiagnosticCode.Type_0_is_not_assignable_to_type_1, decl.range, finalVarType.toString(), "Struct");

package/dist/compiler/AstCompiler/utils/getPropAccessReturnType.js

@@ -9,6 +9,7 @@ import { TirDataT } from "../../tir/types/TirNativeType/native/data.js";
 import { TirFuncT } from "../../tir/types/TirNativeType/native/function.js";
 import { TirIntT } from "../../tir/types/TirNativeType/native/int.js";
 import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../../tir/types/TirNativeType/native/list.js";
 import { isTirOptType } from "../../tir/types/TirNativeType/native/Optional/isTirOptType.js";
 import { TirSopOptT } from "../../tir/types/TirNativeType/native/Optional/sop.js";
@@ -46,6 +47,13 @@ export function getPropAccessReturnType(ctx, objType, propId) {
         return undefined;
     if (objType instanceof TirListT)
         return getListMethods(objType.typeArg)[propName];
+    if (objType instanceof TirLinearMapEntryT) {
+        if (propName === "key")
+            return objType.keyTypeArg;
+        if (propName === "value")
+            return objType.valTypeArg;
+        return undefined;
+    }
     if (objType instanceof TirLinearMapT)
         return getLinearMapMethods(objType.keyTypeArg, objType.valTypeArg)[propName];
     if (objType instanceof TirUnConstrDataResultT)
@@ -85,9 +93,24 @@ function getListMethods(elemsType) {
     };
 }
 function getLinearMapMethods(kT, vT) {
+    const entryType = new TirLinearMapEntryT(kT, vT);
+    const mapType = new TirLinearMapT(kT, vT);
+    const mapReturnT = new TirTypeParam("T");
     return {
-        // ...getListMethods( /* to add when adding support for pairs */ ),
-        lookup: new TirFuncT([kT], new TirSopOptT(vT))
+        length: new TirFuncT([], int_t),
+        isEmpty: new TirFuncT([], bool_t),
+        show: new TirFuncT([], bytes_t),
+        head: new TirFuncT([], entryType),
+        tail: new TirFuncT([], mapType),
+        reverse: new TirFuncT([], mapType),
+        find: new TirFuncT([new TirFuncT([entryType], bool_t)], new TirSopOptT(entryType)),
+        filter: new TirFuncT([new TirFuncT([entryType], bool_t)], mapType),
+        prepend: new TirFuncT([kT, vT], mapType),
+        map: new TirFuncT([new TirFuncT([entryType], mapReturnT)], new TirListT(mapReturnT)),
+        every: new TirFuncT([new TirFuncT([entryType], bool_t)], bool_t),
+        some: new TirFuncT([new TirFuncT([entryType], bool_t)], bool_t),
+        includes: new TirFuncT([entryType], bool_t),
+        lookup: new TirFuncT([kT], new TirSopOptT(vT)),
     };
 }
 const bytesMethods = Object.freeze({

package/dist/compiler/Compiler.js

@@ -42,7 +42,7 @@ export class Compiler extends DiagnosticEmitter {
         const program = await astCompiler.compile();
         if (this.diagnostics.length > 0) {
             let msg;
-            globalThis.console && console.log(this.diagnostics);
+            // globalThis.console && console.log( this.diagnostics );
             const fstErrorMsg = this.diagnostics[0].toString();
             const nDiags = this.diagnostics.length;
             for (msg of this.diagnostics) {

package/dist/compiler/SourceTypeMap.d.ts

@@ -35,6 +35,7 @@ export declare class SourceTypeMap {
     private listMembers;
     private bytesMembers;
     private stringMembers;
+    private linearMapEntryMembers;
     private linearMapMembers;
     private walkFuncExpr;
     private walkExpr;

package/dist/compiler/SourceTypeMap.js

@@ -4,6 +4,7 @@ import { isTirStructType } from "./tir/types/TirStructType.js";
 import { TirFuncT } from "./tir/types/TirNativeType/native/function.js";
 import { TirListT } from "./tir/types/TirNativeType/native/list.js";
 import { TirLinearMapT } from "./tir/types/TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "./tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirBytesT } from "./tir/types/TirNativeType/native/bytes.js";
 import { TirStringT } from "./tir/types/TirNativeType/native/string.js";
 import { TirBoolT } from "./tir/types/TirNativeType/native/bool.js";
@@ -130,6 +131,8 @@ export class SourceTypeMap {
             return [];
         if (type instanceof TirListT)
             return this.listMembers(type.typeArg);
+        if (type instanceof TirLinearMapEntryT)
+            return this.linearMapEntryMembers(type);
         if (type instanceof TirLinearMapT)
             return this.linearMapMembers(type.keyTypeArg, type.valTypeArg);
         return [];
@@ -207,8 +210,30 @@ export class SourceTypeMap {
             { name: "encodeUtf8", type: new TirFuncT([], bytes_t), kind: "method" },
         ];
     }
+    linearMapEntryMembers(type) {
+        return [
+            { name: "key", type: type.keyTypeArg, kind: "field" },
+            { name: "value", type: type.valTypeArg, kind: "field" },
+        ];
+    }
     linearMapMembers(kT, vT) {
+        const entryType = new TirLinearMapEntryT(kT, vT);
+        const mapType = new TirLinearMapT(kT, vT);
+        const mapReturnT = new TirTypeParam("T");
         return [
+            { name: "length", type: new TirFuncT([], int_t), kind: "method" },
+            { name: "isEmpty", type: new TirFuncT([], bool_t), kind: "method" },
+            { name: "show", type: new TirFuncT([], bytes_t), kind: "method" },
+            { name: "head", type: new TirFuncT([], entryType), kind: "method" },
+            { name: "tail", type: new TirFuncT([], mapType), kind: "method" },
+            { name: "reverse", type: new TirFuncT([], mapType), kind: "method" },
+            { name: "find", type: new TirFuncT([new TirFuncT([entryType], bool_t)], new TirSopOptT(entryType)), kind: "method" },
+            { name: "filter", type: new TirFuncT([new TirFuncT([entryType], bool_t)], mapType), kind: "method" },
+            { name: "prepend", type: new TirFuncT([kT, vT], mapType), kind: "method" },
+            { name: "map", type: new TirFuncT([new TirFuncT([entryType], mapReturnT)], new TirListT(mapReturnT)), kind: "method" },
+            { name: "every", type: new TirFuncT([new TirFuncT([entryType], bool_t)], bool_t), kind: "method" },
+            { name: "some", type: new TirFuncT([new TirFuncT([entryType], bool_t)], bool_t), kind: "method" },
+            { name: "includes", type: new TirFuncT([entryType], bool_t), kind: "method" },
             { name: "lookup", type: new TirFuncT([kT], new TirSopOptT(vT)), kind: "method" },
         ];
     }

package/dist/compiler/TirCompiler/expressify/expressify.js

@@ -23,7 +23,11 @@ import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirN
 import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
 import { TirWhileStmt } from "../../tir/statements/TirWhileStmt.js";
+import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
+import { data_t } from "../../tir/program/stdScope/stdScope.js";
+import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirDataStructType, TirSoPStructType } from "../../tir/types/TirStructType.js";
+import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
 import { ExpressifyCtx } from "./ExpressifyCtx.js";
 import { expressifyVarAssignmentStmt } from "./expressifyVarAssignmentStmt.js";
 import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
@@ -130,7 +134,23 @@ loopReplacements, assertions = []) {
             stmt.initExpr = initExpr;
             const lettedName = getUniqueInternalName(stmt.type.toString().toLowerCase());
             const lettedExpr = ctx.introduceLettedConstant(lettedName, initExpr, stmt.range);
-            if (stmt.type instanceof TirSoPStructType) {
+            const stmtUnaliasedType = getUnaliased(stmt.type);
+            if (stmtUnaliasedType instanceof TirLinearMapEntryT) {
+                // LinearMapEntry<K,V> is Pair<Data,Data> at runtime
+                // extract fields via fstPair/sndPair + _inlineFromData
+                for (const [fieldName, varDecl] of stmt.fields) {
+                    if (!(varDecl instanceof TirSimpleVarDecl))
+                        throw new Error("expected simple var decl in entry deconstruction");
+                    const isKey = fieldName === "key";
+                    const fieldType = isKey ? stmtUnaliasedType.keyTypeArg : stmtUnaliasedType.valTypeArg;
+                    const pairAccessor = isKey ? TirNativeFunc.fstPairData : TirNativeFunc.sndPairData;
+                    const fieldLettedName = getUniqueInternalName(`${lettedExpr.varName}_${fieldName}`);
+                    const lettedField = ctx.introduceLettedConstant(fieldLettedName, expressifyVars(ctx, new TirFromDataExpr(new TirCallExpr(pairAccessor, [lettedExpr], data_t, stmt.range), fieldType, stmt.range)), stmt.range);
+                    ctx.setNewVariableName(varDecl.name, lettedField.varName);
+                }
+                continue;
+            }
+            else if (stmtUnaliasedType instanceof TirSoPStructType) {
                 const nestedDeconstructs = flattenSopNamedDeconstructInplace_addTopDestructToCtx_getNestedDeconstruct(stmt, ctx);
                 // nested single constr structs
                 // are added as destructed variables in the matcher body

package/dist/compiler/TirCompiler/expressify/expressifyVars.js

@@ -36,15 +36,18 @@ import { TirUnaryMinus } from "../../tir/expressions/unary/TirUnaryMinus.js";
 import { TirUnaryPlus } from "../../tir/expressions/unary/TirUnaryPlus.js";
 import { isTirUnaryPrefixExpr } from "../../tir/expressions/unary/TirUnaryPrefixExpr.js";
 import { TirUnaryTilde } from "../../tir/expressions/unary/TirUnaryTilde.js";
-import { bool_t, bytes_t, int_t, valueAmountOfName } from "../../tir/program/stdScope/stdScope.js";
+import { bool_t, bytes_t, data_t, int_t, valueAmountOfName } from "../../tir/program/stdScope/stdScope.js";
 import { IRNativeTag } from "../../../IR/IRNodes/IRNative/IRNativeTag.js";
 import { TirReturnStmt } from "../../tir/statements/TirReturnStmt.js";
 import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLikeDeconstr.js";
 import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
 import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirAliasType } from "../../tir/types/TirAliasType.js";
+import { TirBytesT } from "../../tir/types/TirNativeType/native/bytes.js";
+import { TirStringT } from "../../tir/types/TirNativeType/native/string.js";
 import { TirFuncT, TirListT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
 import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
 import { TirDataStructType, TirSoPStructType } from "../../tir/types/TirStructType.js";
 import { getListTypeArg } from "../../tir/types/utils/getListTypeArg.js";
 import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
@@ -331,6 +334,18 @@ function expressifyPropAccess(ctx, propAccessExpr) {
             // we extract the property inplace below (outside this block)
         }
         const objType = getUnaliased(expr.type);
+        if (objType instanceof TirLinearMapEntryT) {
+            // LinearMapEntry<K,V> is Pair<Data,Data> at runtime
+            // .key  => fstPair(expr) then decode from data to K
+            // .value => sndPair(expr) then decode from data to V
+            if (prop === "key") {
+                return new TirFromDataExpr(new TirCallExpr(TirNativeFunc.fstPairData, [expr], data_t, propAccessExpr.range), objType.keyTypeArg, propAccessExpr.range);
+            }
+            if (prop === "value") {
+                return new TirFromDataExpr(new TirCallExpr(TirNativeFunc.sndPairData, [expr], data_t, propAccessExpr.range), objType.valTypeArg, propAccessExpr.range);
+            }
+            throw new Error(`Property '${prop}' does not exist on LinearMapEntry`);
+        }
         if (!isSingleConstrStruct(objType)) {
             // IMPORTANT: we only care about fields here
             // any methods should have already been converted to functions
@@ -443,12 +458,33 @@ function expressifyMethodCall(ctx, methodCall) {
                 throw new Error(`Method 'lookup' of type 'LinearMap' takes 1 argument, ${methodCall.args.length} provided`);
             return new TirCallExpr(TirNativeFunc._lookupLinearMap(objectType.keyTypeArg, objectType.valTypeArg), [methodCall.args[0], objectExpr], methodCall.type, exprRange);
         }
+        if (methodName === "prepend") {
+            if (methodCall.args.length !== 2)
+                throw new Error(`Method 'prepend' of type 'LinearMap' takes 2 arguments (key, value), ${methodCall.args.length} provided`);
+            // encode key and value to data, construct a Pair<Data,Data>, then mkCons
+            const keyToData = new TirToDataExpr(methodCall.args[0], methodCall.args[0].range);
+            const valToData = new TirToDataExpr(methodCall.args[1], methodCall.args[1].range);
+            const mkPair = new TirCallExpr(new TirNativeFunc(IRNativeTag.mkPairData, new TirFuncT([data_t, data_t], new TirPairDataT())), [keyToData, valToData], new TirPairDataT(), exprRange);
+            return new TirCallExpr(TirNativeFunc.mkCons(new TirPairDataT()), [mkPair, objectExpr], methodCall.type, exprRange);
+        }
         // LinearMap is List<PairData> at UPLC level; delegate list methods
         const listType = new TirListT(new TirPairDataT());
         const result = expressifyListMethodCall(ctx, objectExpr, methodCall, methodName, listType, exprRange);
         if (result)
             return result;
     }
+    if (objectType instanceof TirBytesT || objectType instanceof TirStringT) {
+        const exprRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+        if (methodName === "length") {
+            return new TirCallExpr(TirNativeFunc.lengthOfByteString, [objectExpr], int_t, exprRange);
+        }
+        if (methodName === "subByteString" || methodName === "slice") {
+            return new TirCallExpr(TirNativeFunc.sliceByteString, [methodCall.args[0], methodCall.args[1], objectExpr], bytes_t, exprRange);
+        }
+        if (methodName === "prepend") {
+            return new TirCallExpr(TirNativeFunc.consByteString, [methodCall.args[0], objectExpr], bytes_t, exprRange);
+        }
+    }
     throw new Error(`not implemented::expressifyMethodCall for type '${objectType.toString()}' (method name: '${methodName}')`);
     // const tsEnsureExhautstiveCheck: never = objectType;
     throw new Error(`Cannot call method '${methodName}' on non-struct type '${objectType.toString()}'`);

package/dist/compiler/TirCompiler/expressify/toNamedDeconstructVarDecl.js

@@ -1,11 +1,18 @@
 import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
 import { TirSingleDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirSingleDeconstructVarDecl.js";
+import { TirLinearMapEntryT } from "../../tir/types/TirNativeType/native/linearMapEntry.js";
+import { getUnaliased } from "../../tir/types/utils/getUnaliased.js";
 import { isSingleConstrStruct } from "./isSingleConstrStruct.js";
 export function toNamedDeconstructVarDecl(varDecl) {
     if (varDecl instanceof TirNamedDeconstructVarDecl)
         return varDecl;
     if (varDecl instanceof TirSingleDeconstructVarDecl) {
         const declType = varDecl.type;
+        // LinearMapEntry<K,V> uses virtual "Entry" constructor name
+        const unaliased = getUnaliased(declType);
+        if (unaliased instanceof TirLinearMapEntryT) {
+            return new TirNamedDeconstructVarDecl("Entry", varDecl.fields, varDecl.rest, varDecl.type, varDecl.initExpr, varDecl.isConst, varDecl.range);
+        }
         if (!isSingleConstrStruct(declType))
             throw new Error("expected single constr struct type in single deconstruct var decl");
         const singleConstrName = declType.constructors[0].name;

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

@@ -13,6 +13,7 @@ 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 { TirLinearMapEntryT } from "../types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../types/TirNativeType/native/list.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
@@ -64,6 +65,9 @@ export function _inlineFromData(target_t, dataExprIR) {
         // linear maps only have pairs as elements
         // and we only support pairs of data (bc we only have `mkPairData`)
         IRNative.unMapData, dataExprIR);
+    // LinearMapEntry is Pair<Data,Data> at runtime — no conversion needed
+    if (to_t instanceof TirLinearMapEntryT)
+        return dataExprIR;
     if (to_t instanceof TirListT) {
         const elems_t = getUnaliased(getListTypeArg(to_t));
         const listOfDataExpr = _ir_apps(IRNative.unListData, dataExprIR);

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

@@ -99,6 +99,8 @@ export declare class TirNativeFunc implements ITirExpr {
     static get _gtEqBS(): TirNativeFunc;
     static get _gtInt(): TirNativeFunc;
     static get _gtEqInt(): TirNativeFunc;
+    static get fstPairData(): TirNativeFunc;
+    static get sndPairData(): TirNativeFunc;
     static get _pairDataToData(): TirNativeFunc;
     static get _pairDataFromData(): TirNativeFunc;
     static _mkEqualsList(elemT: TirType): TirNativeFunc;

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

@@ -5,6 +5,7 @@ import { bool_t, bytes_t, data_t, int_t, void_t } from "../program/stdScope/stdS
 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 { TirLinearMapEntryT } from "../types/TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../types/TirNativeType/native/list.js";
 import { TirDataOptT } from "../types/TirNativeType/native/Optional/data.js";
 import { TirDataStructType } from "../types/TirStructType.js";
@@ -783,6 +784,12 @@ export class TirNativeFunc {
             int_t
         ], bool_t));
     }
+    static get fstPairData() {
+        return new TirNativeFunc(IRNativeTag.fstPair, new TirFuncT([new TirPairDataT()], data_t));
+    }
+    static get sndPairData() {
+        return new TirNativeFunc(IRNativeTag.sndPair, new TirFuncT([new TirPairDataT()], data_t));
+    }
     static get _pairDataToData() {
         return new TirNativeFunc(IRNativeTag._pairDataToData, new TirFuncT([
             // pair
@@ -832,6 +839,8 @@ export class TirNativeFunc {
             return this.equalsByteString;
         if (t instanceof TirPairDataT)
             return this._equalPairData;
+        if (t instanceof TirLinearMapEntryT)
+            return this._equalPairData;
         if (t instanceof TirBoolT)
             return this._equalBoolean;
         if (t instanceof TirDataT

package/dist/compiler/tir/types/TirNativeType/TirNativeType.d.ts

@@ -6,6 +6,7 @@ import { TirDataT } from "./native/data.js";
 import { TirFuncT } from "./native/function.js";
 import { TirIntT } from "./native/int.js";
 import { TirLinearMapT } from "./native/linearMap.js";
+import { TirLinearMapEntryT } from "./native/linearMapEntry.js";
 import { TirListT } from "./native/list.js";
 import { TirDataOptT } from "./native/Optional/data.js";
 import { TirSopOptT } from "./native/Optional/sop.js";
@@ -13,7 +14,7 @@ import { TirStringT } from "./native/string.js";
 import { TirVoidT } from "./native/void.js";
 export type TirNamedDestructableNativeType = TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType>;
 export declare function isTirNamedDestructableNativeType(t: any): t is TirNamedDestructableNativeType;
-export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType> | TirFuncT | TirUnConstrDataResultT | TirPairDataT;
+export type TirNativeType = TirVoidT | TirBoolT | TirIntT | TirBytesT | TirStringT | TirDataT | TirDataOptT<TirType> | TirSopOptT<TirType> | TirListT<TirType> | TirLinearMapT<TirType, TirType> | TirLinearMapEntryT<TirType, TirType> | TirFuncT | TirUnConstrDataResultT | TirPairDataT;
 export declare function isTirNativeType(t: any): t is TirNativeType;
 export declare class TirUnConstrDataResultT implements ITirType {
     constructor();

package/dist/compiler/tir/types/TirNativeType/TirNativeType.js

@@ -5,6 +5,7 @@ import { TirDataT } from "./native/data.js";
 import { TirFuncT } from "./native/function.js";
 import { TirIntT } from "./native/int.js";
 import { TirLinearMapT } from "./native/linearMap.js";
+import { TirLinearMapEntryT } from "./native/linearMapEntry.js";
 import { TirListT } from "./native/list.js";
 import { TirDataOptT } from "./native/Optional/data.js";
 import { TirSopOptT } from "./native/Optional/sop.js";
@@ -28,6 +29,7 @@ export function isTirNativeType(t) {
         || t instanceof TirSopOptT
         || t instanceof TirListT
         || t instanceof TirLinearMapT
+        || t instanceof TirLinearMapEntryT
         || t instanceof TirFuncT // =>
         || t instanceof TirUnConstrDataResultT
         || t instanceof TirPairDataT);

package/dist/compiler/tir/types/TirNativeType/native/index.d.ts

@@ -5,6 +5,7 @@ export * from "./data.js";
 export * from "./function.js";
 export * from "./int.js";
 export * from "./linearMap.js";
+export * from "./linearMapEntry.js";
 export * from "./list.js";
 export * from "./string.js";
 export * from "./void.js";

package/dist/compiler/tir/types/TirNativeType/native/index.js

@@ -5,6 +5,7 @@ export * from "./data.js";
 export * from "./function.js";
 export * from "./int.js";
 export * from "./linearMap.js";
+export * from "./linearMapEntry.js";
 export * from "./list.js";
 export * from "./string.js";
 export * from "./void.js";

package/dist/compiler/tir/types/TirNativeType/native/linearMapEntry.d.ts

@@ -0,0 +1,17 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirType, ITirType } from "../../TirType.js";
+export declare class TirLinearMapEntryT<K extends TirType = TirType, V extends TirType = TirType> implements ITirType {
+    readonly keyTypeArg: K;
+    readonly valTypeArg: V;
+    constructor(keyTypeArg: K, valTypeArg: V);
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toAstName(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    private _isConcrete;
+    isConcrete(): boolean;
+    clone(): TirLinearMapEntryT<K, V>;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/linearMapEntry.js

@@ -0,0 +1,44 @@
+import { constT } from "@harmoniclabs/uplc";
+import { getAppliedTirTypeName } from "../../../program/TypedProgram.js";
+export class TirLinearMapEntryT {
+    keyTypeArg;
+    valTypeArg;
+    constructor(keyTypeArg, valTypeArg) {
+        this.keyTypeArg = keyTypeArg;
+        this.valTypeArg = valTypeArg;
+    }
+    hasDataEncoding() { return false; }
+    static toTirTypeKey() {
+        return "linear_map_entry";
+    }
+    toTirTypeKey() {
+        return TirLinearMapEntryT.toTirTypeKey();
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return getAppliedTirTypeName(this.toTirTypeKey(), [
+            this.keyTypeArg.toConcreteTirTypeName(),
+            this.valTypeArg.toConcreteTirTypeName()
+        ]);
+    }
+    toString() {
+        return `${this.toTirTypeKey()}<${this.keyTypeArg.toString()},${this.valTypeArg.toString()}>`;
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = (this.keyTypeArg.isConcrete()
+                && this.valTypeArg.isConcrete());
+        return this._isConcrete ?? false;
+    }
+    clone() {
+        const result = new TirLinearMapEntryT(this.keyTypeArg.clone(), this.valTypeArg.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        return constT.pairOf(constT.data, constT.data);
+    }
+}

package/dist/compiler/tir/types/utils/canAssignTo.js

@@ -6,6 +6,7 @@ import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirIntT } from "../TirNativeType/native/int.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../TirNativeType/native/list.js";
 import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
@@ -181,6 +182,12 @@ function uncheckedGetCanAssign(a, b, symbols) {
             return CanAssign.RequiresExplicitCast;
         return CanAssign.No;
     }
+    if (b instanceof TirLinearMapEntryT) {
+        if (a instanceof TirLinearMapEntryT) {
+            return decideCanAssignField(uncheckedGetCanAssign(a.keyTypeArg, b.keyTypeArg, symbols), uncheckedGetCanAssign(a.valTypeArg, b.valTypeArg, symbols));
+        }
+        return CanAssign.No;
+    }
     if (b instanceof TirDataT) {
         if (a instanceof TirDataT)
             return CanAssign.Yes;

package/dist/compiler/tir/types/utils/canCastTo.js

@@ -5,6 +5,7 @@ import { TirDataT } from "../TirNativeType/native/data.js";
 import { TirFuncT } from "../TirNativeType/native/function.js";
 import { TirIntT } from "../TirNativeType/native/int.js";
 import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../TirNativeType/native/list.js";
 import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
 import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
@@ -66,10 +67,8 @@ export function canCastTo(a, b) {
             return true;
         if (a instanceof TirStringT)
             return true; // string -> bytes // decode utf8
-        // how do we handle this?
-        // in theory we can encode but only fixed size
-        // we have no idea of the size of ints
-        // if( a instanceof TirIntT ) return true;
+        if (a instanceof TirIntT)
+            return true; // int -> bytes // big endian encoding
         return false;
     }
     if (b instanceof TirStringT) {
@@ -107,6 +106,13 @@ export function canCastTo(a, b) {
                 && canCastToData(b.valTypeArg));
         return false;
     }
+    if (b instanceof TirLinearMapEntryT) {
+        if (a instanceof TirLinearMapEntryT) {
+            return (canCastTo(a.keyTypeArg, b.keyTypeArg)
+                && canCastTo(a.valTypeArg, b.valTypeArg));
+        }
+        return false;
+    }
     if (b instanceof TirFuncT) {
         if (!(a instanceof TirFuncT))
             return false;

package/dist/compiler/tir/types/utils/getListTypeArg.d.ts

@@ -1,2 +1,3 @@
 import { TirType } from "../TirType.js";
 export declare function getListTypeArg(list_t: TirType): TirType | undefined;
+export declare function getLinearMapTypeArgs(map_t: TirType): [key: TirType, value: TirType] | undefined;

package/dist/compiler/tir/types/utils/getListTypeArg.js

@@ -1,9 +1,20 @@
 import { TirAliasType } from "../TirAliasType.js";
+import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
+import { TirLinearMapEntryT } from "../TirNativeType/native/linearMapEntry.js";
 import { TirListT } from "../TirNativeType/native/list.js";
 export function getListTypeArg(list_t) {
     while (list_t instanceof TirAliasType)
         list_t = list_t.aliased;
     if (list_t instanceof TirListT)
         return list_t.typeArg;
+    if (list_t instanceof TirLinearMapT)
+        return new TirLinearMapEntryT(list_t.keyTypeArg, list_t.valTypeArg);
+    return undefined;
+}
+export function getLinearMapTypeArgs(map_t) {
+    while (map_t instanceof TirAliasType)
+        map_t = map_t.aliased;
+    if (map_t instanceof TirLinearMapT)
+        return [map_t.keyTypeArg, map_t.valTypeArg];
     return undefined;
 }

package/dist/parser/Parser.js

@@ -2409,6 +2409,30 @@ export class Parser extends DiagnosticEmitter {
                     tn.reset(tnState);
                     return true;
                 }
+                // possibly a destructured parameter
+                // ( { field, ... } ) => ...
+                // or a parenthesized object expression
+                // ( { a: 1, b: 2 } )
+                case Token.OpenBrace: {
+                    // skip past the balanced braces
+                    this.skipBlock(tn);
+                    // check what follows the `}`
+                    const afterBrace = tn.next();
+                    if (afterBrace === Token.CloseParen) {
+                        // ( { ... } ) — check for `=>`
+                        const isArrow = tn.skip(Token.FatArrow);
+                        tn.reset(tnState);
+                        return isArrow;
+                    }
+                    if (afterBrace === Token.Comma) {
+                        // ( { ... }, ... ) — multiple params, must be arrow func
+                        tn.reset(tnState);
+                        return true;
+                    }
+                    // anything else — parenthesized expression
+                    tn.reset(tnState);
+                    return false;
+                }
                 // can be both parenthesized expression or function parameter
                 // ( Identifier...
                 case Token.Identifier: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",