@harmoniclabs/pebble 0.1.3 → 0.1.4-dev1

package/dist/IR/IRNodes/IRNative/IRNativeTag.d.ts

@@ -134,6 +134,7 @@ export declare enum IRNativeTag {
     _getCredentialsHash = -44,
     _findSopOptional = -45,
     _increment = -46,
-    _decrement = -47
+    _decrement = -47,
+    _lookupLinearMap = -48
 }
 export declare function nativeTagToString(nativeTag: IRNativeTag): string;

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

@@ -158,6 +158,7 @@ export var IRNativeTag;
     IRNativeTag[IRNativeTag["_findSopOptional"] = -45] = "_findSopOptional";
     IRNativeTag[IRNativeTag["_increment"] = -46] = "_increment";
     IRNativeTag[IRNativeTag["_decrement"] = -47] = "_decrement";
+    IRNativeTag[IRNativeTag["_lookupLinearMap"] = -48] = "_lookupLinearMap";
 })(IRNativeTag || (IRNativeTag = {}));
 Object.freeze(IRNativeTag);
 export function nativeTagToString(nativeTag) {
@@ -203,6 +204,7 @@ export function nativeTagToString(nativeTag) {
         case IRNativeTag._getCredentialsHash: return "getCredentialHash";
         case IRNativeTag._increment: return "increment";
         case IRNativeTag._decrement: return "decrement";
+        case IRNativeTag._lookupLinearMap: return "lookupLinearMap";
         default: return "";
     }
 }

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.d.ts

@@ -24,6 +24,7 @@ export declare const hoisted_length: IRHoisted;
 export declare const hoisted_dropList: IRHoisted;
 export declare const hoisted_sizeofPositiveInt: IRHoisted;
 export declare const hoisted_findSopOptional: IRHoisted;
+export declare const hoisted_lookupLinearMap: IRHoisted;
 export declare const hoisted_mkFindDataOptional: IRHoisted;
 export declare const hoisted_strictAnd: IRHoisted;
 export declare const hoisted_strictOr: IRHoisted;

package/dist/IR/toUPLC/subRoutines/replaceNatives/nativeToIR.js

@@ -122,12 +122,30 @@ export const hoisted_findSopOptional = new IRHoisted(new IRFunc([findSop_predica
 // case nil
 new IRConstr(1, []), // None
 // case cons
-new IRFunc([findSop_head], _ir_lazyIfThenElse(_ir_apps(new IRVar(findSop_predicate), new IRVar(findSop_head)), 
+new IRApp(new IRFunc([findSop_head], _ir_lazyIfThenElse(_ir_apps(new IRVar(findSop_predicate), new IRVar(findSop_head)), 
 // then => Some(head)
-new IRConstr(1, [new IRVar(findSop_head)]), // Some{ head }
+new IRConstr(0, [new IRVar(findSop_head)]), // Some{ head }
 // else => self(tail)
-_ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))))))));
+_ir_apps(new IRSelfCall(findSop_self), _ir_apps(IRNative.tailList, new IRVar(findSop_list))))), new IRApp(IRNative.headList, new IRVar(findSop_list))))))));
 hoisted_findSopOptional.hash;
+// hoisted _lookupLinearMap
+// (key: data) -> (map: list<pair<data,data>>) -> SopOptional<data>
+const lookup_key = Symbol("lookup_key");
+const lookup_self = Symbol("lookup_self");
+const lookup_map = Symbol("lookup_map");
+const lookup_head = Symbol("lookup_head");
+export const hoisted_lookupLinearMap = new IRHoisted(new IRFunc([lookup_key], new IRRecursive(lookup_self, new IRFunc([lookup_map], _ir_lazyChooseList(new IRVar(lookup_map), 
+// case nil => None
+new IRConstr(1, []), 
+// case cons
+new IRApp(new IRFunc([lookup_head], _ir_lazyIfThenElse(_ir_apps(IRNative.equalsData, _ir_apps(IRNative.fstPair, new IRVar(lookup_head)), new IRVar(lookup_key)), 
+// then => Some(sndPair(head))
+new IRConstr(0, [
+    _ir_apps(IRNative.sndPair, new IRVar(lookup_head))
+]), 
+// else => self(tailList(map))
+_ir_apps(new IRSelfCall(lookup_self), _ir_apps(IRNative.tailList, new IRVar(lookup_map))))), new IRApp(IRNative.headList, new IRVar(lookup_map))))))));
+hoisted_lookupLinearMap.hash;
 // hoisted _mkFindDataOptional
 const mkFind_elemToData = Symbol("elemToData");
 const mkFind_pred = Symbol("predicate");
@@ -265,6 +283,7 @@ export function nativeToIR(native) {
         // case IRNativeTag._equalPairData: ;
         case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         case IRNativeTag._negateInt: return hoisted_negateInteger.clone();
+        case IRNativeTag._lookupLinearMap: return hoisted_lookupLinearMap.clone();
         // case IRNativeTag._mkEqualsList: return hoisted_mkEqualsList.clone();
         default:
             throw new Error("unknown (negative) native calling 'nativeToIR'; " +

package/dist/ast/nodes/expr/litteral/LitNamedObjExpr.d.ts

@@ -8,5 +8,9 @@ export declare class LitNamedObjExpr implements HasSourceRange, ILibObjExpr {
     readonly fieldNames: Identifier[];
     readonly values: PebbleExpr[];
     readonly range: SourceRange;
-    constructor(name: Identifier, fieldNames: Identifier[], values: PebbleExpr[], range: SourceRange);
+    /** When using `Type.Constructor{ ... }` syntax, this is the type name */
+    readonly typeName: Identifier | undefined;
+    constructor(name: Identifier, fieldNames: Identifier[], values: PebbleExpr[], range: SourceRange, 
+    /** When using `Type.Constructor{ ... }` syntax, this is the type name */
+    typeName?: Identifier | undefined);
 }

package/dist/ast/nodes/expr/litteral/LitNamedObjExpr.js

@@ -3,10 +3,14 @@ export class LitNamedObjExpr {
     fieldNames;
     values;
     range;
-    constructor(name, fieldNames, values, range) {
+    typeName;
+    constructor(name, fieldNames, values, range, 
+    /** When using `Type.Constructor{ ... }` syntax, this is the type name */
+    typeName = undefined) {
         this.name = name;
         this.fieldNames = fieldNames;
         this.values = values;
         this.range = range;
+        this.typeName = typeName;
     }
 }

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

@@ -93,7 +93,23 @@ export function _compileLitteralNamedObjExpr(ctx, expr, typeHint) {
     else
         typeHint = undefined;
     const constructorName = expr.name.text;
-    const inferredStructType = getStructType(ctx.scope.inferStructTypeFromConstructorName(constructorName)?.structType);
+    let inferredStructType = undefined;
+    // Type.Constructor{ ... } syntax — resolve type directly
+    if (expr.typeName) {
+        const possibleTypes = ctx.scope.resolveType(expr.typeName.text);
+        if (possibleTypes) {
+            const dataTirName = possibleTypes.dataTirName;
+            const sopTirName = possibleTypes.sopTirName;
+            inferredStructType = getStructType((dataTirName ? ctx.program.types.get(dataTirName) : undefined)
+                ?? ctx.program.types.get(sopTirName));
+        }
+        if (!inferredStructType) {
+            return ctx.error(DiagnosticCode._0_is_not_defined, expr.typeName.range, expr.typeName.text);
+        }
+    }
+    else {
+        inferredStructType = getStructType(ctx.scope.inferStructTypeFromConstructorName(constructorName)?.structType);
+    }
     if (!inferredStructType) {
         return ctx.error(DiagnosticCode._0_is_not_defined, expr.name.range, constructorName);
     }
@@ -105,7 +121,11 @@ export function _compileLitteralNamedObjExpr(ctx, expr, typeHint) {
     structType = inferredStructType;
     if (!isTirType(typeHint))
         typeHint = structType ?? inferredStructType;
-    const fieldValues = __commonCompileStructFieldValues(ctx, expr, typeHint, structType, structType?.constructors.findIndex(c => c.name === constructorName) ?? -1);
+    const constructorIndex = structType?.constructors.findIndex(c => c.name === constructorName) ?? -1;
+    if (constructorIndex < 0) {
+        return ctx.error(DiagnosticCode._0_is_not_defined, expr.name.range, constructorName);
+    }
+    const fieldValues = __commonCompileStructFieldValues(ctx, expr, typeHint, structType, constructorIndex);
     if (!Array.isArray(fieldValues))
         return undefined;
     typeHint = getUnaliased(typeHint);

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

@@ -108,6 +108,15 @@ function getStructPropAccessReturnType(ctx, structType, propName) {
         if (field)
             return field.type;
     }
+    // constructor accessor methods for multi-constructor data structs
+    // e.g. ExtendedInteger.finite() returns int (the field of the Finite constructor)
+    if (structType.constructors.length > 1) {
+        const lowerPropName = propName.toLowerCase();
+        const ctor = structType.constructors.find(c => c.name.toLowerCase() === lowerPropName);
+        if (ctor && ctor.fields.length === 1) {
+            return new TirFuncT([], ctor.fields[0].type);
+        }
+    }
     return findPropInImpls(ctx, structType.methodNamesPtr, propName);
 }
 function findPropInImpls(ctx, methodsNamesPtr, propName) {

package/dist/compiler/SourceTypeMap.js

@@ -143,6 +143,19 @@ export class SourceTypeMap {
                 result.push({ name: field.name, type: field.type, kind: "field" });
             }
         }
+        // constructor accessor methods for multi-constructor structs
+        // e.g. ExtendedInteger.finite() returns int
+        if (type.constructors.length > 1) {
+            for (const ctor of type.constructors) {
+                if (ctor.fields.length === 1) {
+                    result.push({
+                        name: ctor.name.toLowerCase(),
+                        type: new TirFuncT([], ctor.fields[0].type),
+                        kind: "method"
+                    });
+                }
+            }
+        }
         // methods
         result.push(...this.methodsFromMap(type.methodNamesPtr));
         return result;

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

@@ -14,7 +14,7 @@ import { TirLitUndefExpr } from "../../tir/expressions/litteral/TirLitUndefExpr.
 import { TirLitVoidExpr } from "../../tir/expressions/litteral/TirLitVoidExpr.js";
 import { TirAssertAndContinueExpr } from "../../tir/expressions/TirAssertAndContinueExpr.js";
 import { TirCallExpr } from "../../tir/expressions/TirCallExpr.js";
-import { TirCaseExpr, TirCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
+import { TirCaseExpr, TirCaseMatcher, TirWildcardCaseMatcher } from "../../tir/expressions/TirCaseExpr.js";
 import { TirElemAccessExpr } from "../../tir/expressions/TirElemAccessExpr.js";
 import { TirFailExpr } from "../../tir/expressions/TirFailExpr.js";
 import { TirFromDataExpr } from "../../tir/expressions/TirFromDataExpr.js";
@@ -42,7 +42,8 @@ import { TirArrayLikeDeconstr } from "../../tir/statements/TirVarDecl/TirArrayLi
 import { TirNamedDeconstructVarDecl } from "../../tir/statements/TirVarDecl/TirNamedDeconstructVarDecl.js";
 import { TirSimpleVarDecl } from "../../tir/statements/TirVarDecl/TirSimpleVarDecl.js";
 import { TirAliasType } from "../../tir/types/TirAliasType.js";
-import { TirFuncT, TirListT } from "../../tir/types/TirNativeType/index.js";
+import { TirFuncT, TirListT, TirPairDataT } from "../../tir/types/TirNativeType/index.js";
+import { TirLinearMapT } from "../../tir/types/TirNativeType/native/linearMap.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";
@@ -67,9 +68,6 @@ export function expressifyVars(ctx, expr) {
         || expr instanceof TirLitTrueExpr
         || expr instanceof TirLitFalseExpr
         || expr instanceof TirLitThisExpr
-        || expr instanceof TirLitArrExpr
-        || expr instanceof TirLitObjExpr
-        || expr instanceof TirLitNamedObjExpr
         || expr instanceof TirLitStrExpr
         || expr instanceof TirLitIntExpr
         || expr instanceof TirLitHexBytesExpr
@@ -77,6 +75,19 @@ export function expressifyVars(ctx, expr) {
         // hoisted expressions are necessarily closed, so no external variables
         || expr instanceof TirHoistedExpr)
         return expr;
+    if (expr instanceof TirLitObjExpr
+        || expr instanceof TirLitNamedObjExpr) {
+        for (let i = 0; i < expr.values.length; i++) {
+            expr.values[i] = expressifyVars(ctx, expr.values[i]);
+        }
+        return expr;
+    }
+    if (expr instanceof TirLitArrExpr) {
+        for (let i = 0; i < expr.elems.length; i++) {
+            expr.elems[i] = expressifyVars(ctx, expr.elems[i]);
+        }
+        return expr;
+    }
     // every property access must be replaced with a variable access (or similar)
     // that is either letted/hoisted/nativeFunc/varAccess expression
     //
@@ -374,6 +385,29 @@ function expressifyMethodCall(ctx, methodCall) {
     }
     if (objectType instanceof TirDataStructType
         || objectType instanceof TirSoPStructType) {
+        // constructor accessor methods for multi-constructor structs
+        // e.g. ExtendedInteger.finite() asserts Finite and returns int
+        if (objectType.constructors.length > 1 && methodCall.args.length === 0) {
+            const lowerMethodName = methodName.toLowerCase();
+            const ctor = objectType.constructors.find(c => c.name.toLowerCase() === lowerMethodName);
+            if (ctor && ctor.fields.length === 1) {
+                const fName = ctor.fields[0].name;
+                const fType = ctor.fields[0].type;
+                const exprRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+                return new TirCaseExpr(objectExpr, [
+                    new TirCaseMatcher(new TirNamedDeconstructVarDecl(ctor.name, new Map([
+                        [fName, new TirSimpleVarDecl(fName, fType, undefined, true, exprRange)]
+                    ]), undefined, objectExpr.type, undefined, true, exprRange), new TirVariableAccessExpr({
+                        variableInfos: {
+                            name: fName,
+                            type: fType,
+                            isConstant: true,
+                        },
+                        isDefinedOutsideFuncScope: false,
+                    }, exprRange), exprRange)
+                ], new TirWildcardCaseMatcher(new TirFailExpr(undefined, fType, exprRange), exprRange), fType, exprRange);
+            }
+        }
         const structMethods = objectType.methodNamesPtr;
         const tirMethodName = structMethods.get(methodName);
         if (!tirMethodName)
@@ -388,6 +422,19 @@ function expressifyMethodCall(ctx, methodCall) {
         if (result)
             return result;
     }
+    if (objectType instanceof TirLinearMapT) {
+        const exprRange = SourceRange.join(methodIdentifierProp.range, methodCall.range.atEnd());
+        if (methodName === "lookup") {
+            if (methodCall.args.length !== 1)
+                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);
+        }
+        // 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;
+    }
     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/tir/expressions/TirCaseExpr.js

@@ -3,7 +3,6 @@ import { IRCase } from "../../../IR/IRNodes/IRCase.js";
 import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRDelayed } from "../../../IR/IRNodes/IRDelayed.js";
 import { IRError } from "../../../IR/IRNodes/IRError.js";
-import { IRForced } from "../../../IR/IRNodes/IRForced.js";
 import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { IRVar } from "../../../IR/IRNodes/IRVar.js";
@@ -87,17 +86,26 @@ export class TirCaseExpr {
             const someBranchCtx = ctx.newChild();
             const someBranch = this.cases.find(c => c.pattern.constrName === "Some");
             let someBranchVarSym = Symbol("some_value_unused");
+            let someValueType = undefined;
             if (someBranch) {
                 const varDecl = someBranch.pattern.fields.values().next().value;
                 if (!(varDecl instanceof TirSimpleVarDecl))
                     throw new Error("case pattern not expressified.");
                 someBranchVarSym = someBranchCtx.defineVar(varDecl.name);
+                someValueType = varDecl.type;
             }
             const someBranchIR = someBranch?.body.toIR(someBranchCtx) ?? wildcardBodyIR;
             const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(ctx) ?? wildcardBodyIR;
+            // The SoP Optional wraps raw data values from lookups;
+            // apply _inlineFromData to convert to the expected native type
+            // (e.g., unMapData for LinearMap values)
+            const rawValueSym = Symbol("sop_opt_raw_value");
+            const someHandler = someValueType
+                ? new IRFunc([rawValueSym], new IRApp(new IRFunc([someBranchVarSym], someBranchIR), _inlineFromData(someValueType, new IRVar(rawValueSym))))
+                : new IRFunc([someBranchVarSym], someBranchIR);
             return new IRCase(this.matchExpr.toIR(ctx), [
                 // Some{ value }
-                new IRFunc([someBranchVarSym], someBranchIR),
+                someHandler,
                 // None
                 noneBranchIR
             ]);
@@ -160,14 +168,14 @@ export class TirCaseExpr {
                 )));
             }
             const noneBranchIR = this.cases.find(c => c.pattern.constrName === "None")?.body.toIR(stmtCtx) ?? wildcardBodyIR;
-            return new IRForced(_ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), unConstrMatchSym => _ir_lazyIfThenElse(
+            return _ir_let(_ir_apps(IRNative.unConstrData, this.matchExpr.toIR(ctx)), unConstrMatchSym => _ir_lazyIfThenElse(
             // condition
             _ir_apps(IRNative.equalsInteger, IRConst.int(0), _ir_apps(IRNative.fstPair, new IRVar(unConstrMatchSym) // unConstrData result
             )), 
             // then Just{ value }
             someBranchIR(unConstrMatchSym), 
             // else None
-            noneBranchIR)));
+            noneBranchIR));
         }
         // TirDataStructType
         const stmtCtx = ctx.newChild();

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

@@ -85,6 +85,7 @@ export declare class TirNativeFunc implements ITirExpr {
     static _foldr(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _foldl(elemT: TirType, returnT: TirType): TirNativeFunc;
     static _findSopOptional(elems_t: TirType): TirNativeFunc;
+    static _lookupLinearMap(keyT: TirType, valT: TirType): TirNativeFunc;
     static _length(elemT: TirType): TirNativeFunc;
     static _some(elemT: TirType): TirNativeFunc;
     static _every(elemT: TirType): TirNativeFunc;

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

@@ -684,6 +684,14 @@ export class TirNativeFunc {
             new TirListT(elems_t)
         ], new TirSopOptT(elems_t)));
     }
+    static _lookupLinearMap(keyT, valT) {
+        return new TirNativeFunc(IRNativeTag._lookupLinearMap, new TirFuncT([
+            // key: data
+            data_t,
+            // map: list<pair<data,data>>
+            new TirLinearMapT(keyT, valT)
+        ], new TirSopOptT(valT)));
+    }
     static _length(elemT) {
         return new TirNativeFunc(IRNativeTag._length, new TirFuncT([
             // list

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

@@ -0,0 +1,30 @@
+import { SourceRange } from "../../../ast/Source/SourceRange.js";
+import type { 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";
+/**
+ * Converts a SoP Optional value to a boolean at the IR level
+ * using `case(opt, [\_ -> true, false])`.
+ *
+ * This is needed because `ifThenElse` expects a boolean, but
+ * SoP Optional values are Constr nodes, not boolean constants.
+ */
+export declare class TirSopOptToBoolExpr implements ITirExpr {
+    readonly operand: TirExpr;
+    readonly range: SourceRange;
+    readonly type: TirType;
+    constructor(operand: TirExpr, range: SourceRange);
+    toString(): string;
+    pretty(indent: number): string;
+    clone(): TirExpr;
+    deps(): string[];
+    get isConstant(): boolean;
+    toIR(ctx: ToIRTermCtx): IRTerm;
+    /**
+     * Wraps the expression in TirSopOptToBoolExpr if its type is SoP Optional,
+     * otherwise returns it as-is.
+     */
+    static wrapIfNeeded(expr: TirExpr): TirExpr;
+}

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

@@ -0,0 +1,49 @@
+import { IRCase } from "../../../IR/IRNodes/IRCase.js";
+import { IRConst } from "../../../IR/IRNodes/IRConst.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { bool_t } from "../program/stdScope/stdScope.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
+/**
+ * Converts a SoP Optional value to a boolean at the IR level
+ * using `case(opt, [\_ -> true, false])`.
+ *
+ * This is needed because `ifThenElse` expects a boolean, but
+ * SoP Optional values are Constr nodes, not boolean constants.
+ */
+export class TirSopOptToBoolExpr {
+    operand;
+    range;
+    type = bool_t;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+    toString() { return `isSome(${this.operand.toString()})`; }
+    pretty(indent) { return `isSome(${this.operand.pretty(indent)})`; }
+    clone() {
+        return new TirSopOptToBoolExpr(this.operand.clone(), this.range.clone());
+    }
+    deps() { return this.operand.deps(); }
+    get isConstant() { return this.operand.isConstant; }
+    toIR(ctx) {
+        const unusedSym = Symbol("_some_val");
+        return new IRCase(this.operand.toIR(ctx), [
+            // Some{ value } => true
+            new IRFunc([unusedSym], IRConst.bool(true)),
+            // None => false
+            IRConst.bool(false)
+        ]);
+    }
+    /**
+     * Wraps the expression in TirSopOptToBoolExpr if its type is SoP Optional,
+     * otherwise returns it as-is.
+     */
+    static wrapIfNeeded(expr) {
+        const t = getUnaliased(expr.type);
+        if (t instanceof TirSopOptT) {
+            return new TirSopOptToBoolExpr(expr, expr.range);
+        }
+        return expr;
+    }
+}

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

@@ -4,6 +4,10 @@ import { IRConst } from "../../../IR/IRNodes/IRConst.js";
 import { IRNative } from "../../../IR/IRNodes/IRNative/index.js";
 import { _ir_apps } from "../../../IR/IRNodes/IRApp.js";
 import { _ir_lazyIfThenElse } from "../../../IR/tree_utils/_ir_lazyIfThenElse.js";
+import { IRCase } from "../../../IR/IRNodes/index.js";
+import { IRFunc } from "../../../IR/IRNodes/IRFunc.js";
+import { TirSopOptT } from "../types/TirNativeType/native/Optional/sop.js";
+import { getUnaliased } from "../types/utils/getUnaliased.js";
 export class TirTraceIfFalseExpr {
     condition;
     traceStrExpr;
@@ -34,6 +38,17 @@ export class TirTraceIfFalseExpr {
         return new TirTraceIfFalseExpr(this.condition.clone(), this.traceStrExpr.clone(), this.range.clone());
     }
     toIR(ctx) {
+        const condType = getUnaliased(this.condition.type);
+        // SoP Optional: use case expression to convert to bool
+        if (condType instanceof TirSopOptT) {
+            const unusedSym = Symbol("_some_val");
+            return new IRCase(this.condition.toIR(ctx), [
+                // Some{ value } => true
+                new IRFunc([unusedSym], IRConst.bool(true)),
+                // None => trace(msg, false)
+                _ir_apps(IRNative.trace, this.traceStrExpr.toIR(ctx), IRConst.bool(false))
+            ]);
+        }
         return _ir_lazyIfThenElse(
         // condition
         this.condition.toIR(ctx), 

package/dist/compiler/tir/statements/TirAssertStmt.js

@@ -1,5 +1,6 @@
 import { mergeSortedStrArrInplace } from "../../../utils/array/mergeSortedStrArrInplace.js";
 import { TirTraceIfFalseExpr } from "../expressions/TirTraceIfFalseExpr.js";
+import { TirSopOptToBoolExpr } from "../expressions/TirSopOptToBoolExpr.js";
 export class TirAssertStmt {
     condition;
     elseExpr;
@@ -32,8 +33,9 @@ export class TirAssertStmt {
         return deps;
     }
     toSafeCondition() {
-        if (!this.elseExpr)
-            return this.condition;
+        if (!this.elseExpr) {
+            return TirSopOptToBoolExpr.wrapIfNeeded(this.condition);
+        }
         return new TirTraceIfFalseExpr(this.condition, this.elseExpr, this.range);
     }
 }

package/dist/parser/Parser.js

@@ -1491,6 +1491,23 @@ export class Parser extends DiagnosticEmitter {
                     }
                     return new LitNamedObjExpr(identifier, litObjExpr.fieldNames, litObjExpr.values, SourceRange.join(identifier.range, litObjExpr.range));
                 }
+                // LitNamedObjExpr with type qualifier
+                // eg: `Type.Constructor{ a: 1, b: 2 }`
+                if (tn.peek() === Token.Dot) {
+                    const savedState = tn.mark();
+                    tn.next(); // consume '.'
+                    if (tn.skipIdentifier(IdentifierHandling.Always)) {
+                        const ctorIdentifier = new Identifier(tn.readIdentifier(), tn.range());
+                        if (tn.peek() === Token.OpenBrace) {
+                            const litObjExpr = this.parseExprStart();
+                            if (litObjExpr instanceof LitObjExpr) {
+                                return new LitNamedObjExpr(ctorIdentifier, litObjExpr.fieldNames, litObjExpr.values, SourceRange.join(identifier.range, litObjExpr.range), identifier // typeName
+                                );
+                            }
+                        }
+                    }
+                    tn.reset(savedState);
+                }
                 // param => ...
                 if (tn.peek() === Token.FatArrow
                 // && !tn.isNextTokenOnNewLine() // original impl had this, not sure why

package/package.json

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