@harmoniclabs/pebble 0.1.4-dev0 → 0.1.4-dev1

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

@@ -122,11 +122,11 @@ 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>
@@ -138,13 +138,13 @@ export const hoisted_lookupLinearMap = new IRHoisted(new IRFunc([lookup_key], ne
 // case nil => None
 new IRConstr(1, []), 
 // case cons
-new IRFunc([lookup_head], _ir_lazyIfThenElse(_ir_apps(IRNative.equalsData, _ir_apps(IRNative.fstPair, new IRVar(lookup_head)), new IRVar(lookup_key)), 
+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(1, [
+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))))))))));
+_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");

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.4-dev0",
+  "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",