@harmoniclabs/pebble 0.1.3-dev0 → 0.1.3-dev1

package/dist/IR/IRNodes/IRConst.js

@@ -1,4 +1,3 @@
-import { Pair } from "@harmoniclabs/pair";
 import { isData, dataToCbor } from "@harmoniclabs/plutus-data";
 import { fromUtf8, toHex } from "@harmoniclabs/uint8array-utils";
 import { BasePlutsError } from "../../utils/BasePlutsError.js";
@@ -11,7 +10,7 @@ import { TirAliasType } from "../../compiler/tir/types/TirAliasType.js";
 import { TirDataStructType, TirSoPStructType } from "../../compiler/tir/types/TirStructType.js";
 import { getListTypeArg } from "../../compiler/tir/types/utils/getListTypeArg.js";
 import { TirTypeParam } from "../../compiler/tir/types/TirTypeParam.js";
-import { constT, UPLCConst } from "@harmoniclabs/uplc";
+import { constT, isPair, UPLCConst } from "@harmoniclabs/uplc";
 import { TirPairDataT, TirUnConstrDataResultT } from "../../compiler/tir/types/TirNativeType/index.js";
 import { TirBoolT } from "../../compiler/tir/types/TirNativeType/native/bool.js";
 import { TirBytesT } from "../../compiler/tir/types/TirNativeType/native/bytes.js";
@@ -25,10 +24,9 @@ import { TirSopOptT } from "../../compiler/tir/types/TirNativeType/native/Option
 import { TirStringT } from "../../compiler/tir/types/TirNativeType/native/string.js";
 import { TirVoidT } from "../../compiler/tir/types/TirNativeType/native/void.js";
 import { hashIrData, isIRHash } from "../IRHash.js";
-import { ByteString } from "@harmoniclabs/bytestring";
 import { UPLCFlatUtils } from "../../utils/UPLCFlatUtils/index.js";
 export function isIRConstPair(value) {
-    return (value instanceof Pair &&
+    return (isPair(value) &&
         isIRConstValue(value.fst) &&
         isIRConstValue(value.snd));
 }
@@ -65,7 +63,7 @@ export class IRConst {
         const type = getUnaliased(this.type);
         if (type instanceof TirBytesT && this.value instanceof Uint8Array) {
             // make a copy to prevent external mutation
-            return new UPLCConst(tirTypeToUplcType(type), new ByteString(this.value));
+            return new UPLCConst(tirTypeToUplcType(type), this.value);
         }
         return new UPLCConst(tirTypeToUplcType(type), this.value);
     }
@@ -215,7 +213,7 @@ function serializeIRConstValue(value, type) {
     if (type instanceof TirDataT
         || type instanceof TirDataOptT
         || type instanceof TirDataStructType)
-        return dataToCbor(value).toBuffer();
+        return dataToCbor(value);
     if (type instanceof TirFuncT
         || type instanceof TirSopOptT
         || type instanceof TirSoPStructType

package/dist/IR/toUPLC/compileIRToUPLC.js

@@ -20,6 +20,7 @@ import { _debug_assertClosedIR } from "../utils/index.js";
 import { ToUplcCtx } from "./ctx/ToUplcCtx.js";
 import { removeUnusedVarsAndReturnRoot } from "./subRoutines/removeUnusuedVarsAndReturnRoot/removeUnusuedVarsAndReturnRoot.js";
 import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import { ensureProperlyForcedBuiltinsAndReturnRoot } from "./subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.js";
 export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // most of the time we are just compiling small
     // pre-execuded terms (hence constants)
@@ -144,6 +145,7 @@ export function compileIRToUPLC(term, paritalOptions = defaultOptions) {
     // }
     term = removeUnusedVarsAndReturnRoot(term);
     term = performUplcOptimizationsAndReturnRoot(term, options);
+    term = ensureProperlyForcedBuiltinsAndReturnRoot(term);
     if (options.addMarker &&
         options.targetUplcVersion.major >= 1 &&
         options.targetUplcVersion.minor >= 1 &&

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.d.ts

@@ -0,0 +1,2 @@
+import { IRTerm } from "../../../IRTerm.js";
+export declare function ensureProperlyForcedBuiltinsAndReturnRoot(root: IRTerm): IRTerm;

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/ensureProperlyForcedBuiltinsAndReturnRoot.js

@@ -0,0 +1,163 @@
+import { IRConstr, IRNative } from "../../../IRNodes/index.js";
+import { IRApp } from "../../../IRNodes/IRApp.js";
+import { IRCase } from "../../../IRNodes/IRCase.js";
+import { IRForced } from "../../../IRNodes/IRForced.js";
+import { IRFunc } from "../../../IRNodes/IRFunc.js";
+import { IRHoisted } from "../../../IRNodes/IRHoisted.js";
+import { IRLetted } from "../../../IRNodes/IRLetted.js";
+import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
+import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
+import { getApplicationTerms } from "../../utils/getApplicationTerms.js";
+import { getUnboundedVars } from "../handleLetted/groupByScope.js";
+import { getNRequiredForces } from "@harmoniclabs/uplc";
+export function ensureProperlyForcedBuiltinsAndReturnRoot(root) {
+    // const opts = options.uplcOptimizations;
+    // if( isDebugUplcOptimizations( opts ) ) return root;
+    // const {
+    //     groupApplications,
+    //     inlineSingleUse: shouldInlineSingleUse,
+    //     simplifyWrappedPartialFuncApps,
+    //     removeForceDelay
+    // } = opts;
+    const stack = [root];
+    let t = root;
+    while (t = stack.pop()) {
+        if (t instanceof IRNative) {
+            const expectedForces = getNRequiredForces(t.tag);
+            if (expectedForces <= 0)
+                continue;
+            let newNode = t;
+            let nDirectForces = 0;
+            // save the original parent before walking up through existing forces
+            // and before creating new IRForced wrappers (whose constructors
+            // overwrite the child's parent pointer)
+            const originalParent = t.parent;
+            while (t.parent instanceof IRForced) {
+                nDirectForces++;
+                t = t.parent;
+            }
+            if (nDirectForces === expectedForces)
+                continue;
+            // when nDirectForces > 0, t has walked up to the topmost IRForced;
+            // save its parent before wrapping overwrites parent pointers
+            const replaceInParent = nDirectForces > 0 ? t.parent : originalParent;
+            for (let i = 0; i < expectedForces - nDirectForces; i++) {
+                newNode = new IRForced(newNode);
+            }
+            if (replaceInParent)
+                _modifyChildFromTo(replaceInParent, t, newNode);
+            else
+                root = newNode;
+            continue;
+        }
+        if (t instanceof IRRecursive ||
+            t instanceof IRHoisted ||
+            t instanceof IRLetted ||
+            t instanceof IRSelfCall)
+            throw new Error("Unexpected term while performing uplc optimizations");
+        stack.push(...t.children());
+    }
+    return root;
+}
+function isIdLike(term) {
+    return (term instanceof IRFunc &&
+        term.params.length === 1 &&
+        term.body instanceof IRVar &&
+        term.body.name === term.params[0]);
+}
+/**
+ *
+ * @returns either an object containing the new root, sorted args and next body
+ *          or undefined if grouping wasnt possible (root is the same)
+ */
+function groupIndependentApplications(root) {
+    const parent = root.parent;
+    let applicaitonTerms = getApplicationTerms(root);
+    if (!applicaitonTerms)
+        return undefined;
+    let { func, args } = applicaitonTerms;
+    if (!(func instanceof IRFunc))
+        return undefined;
+    const params = func.params.slice();
+    while (true) {
+        applicaitonTerms = getApplicationTerms(func.body);
+        if (!applicaitonTerms)
+            break;
+        if (!(applicaitonTerms.func instanceof IRFunc))
+            break;
+        func = applicaitonTerms.func;
+        params.push(...func.params);
+        args.push(...applicaitonTerms.args);
+        if (params.length !== args.length)
+            break;
+    }
+    const len = Math.min(params.length, args.length);
+    const finalParams = params.slice(len);
+    const finalArgs = args.slice(len);
+    params.length = len;
+    args.length = len;
+    const paramToArg = {};
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        paramToArg[p] = args[i];
+    }
+    const globalUnbound = getUnboundedVars(root);
+    const groups = [[]];
+    for (let i = 0; i < len; i++) {
+        const p = params[i];
+        const arg = args[i];
+        const unbound = getUnboundedVars(arg, globalUnbound);
+        let highestIdx = -1;
+        for (let j = groups.length - 1; j >= 0; j--) {
+            const group = groups[j];
+            if (group.some(sym => unbound.has(sym))) {
+                highestIdx = j;
+                break;
+            }
+        }
+        if (highestIdx === groups.length - 1) {
+            groups.push([p]);
+            continue;
+        }
+        groups[highestIdx + 1].push(p);
+    }
+    groups[groups.length - 1].push(...finalParams);
+    const sortedArgs = new Array(len);
+    const soretedParams = groups.flat();
+    for (let i = 0; i < len; i++) {
+        const p = soretedParams[i];
+        sortedArgs[i] = paramToArg[p];
+    }
+    let nextBody = func.body;
+    if (finalArgs.length > 0) {
+        if (finalArgs.length === 1) {
+            nextBody = new IRApp(nextBody, finalArgs[0]);
+        }
+        else {
+            nextBody = new IRCase(new IRConstr(0, finalArgs), [nextBody]);
+        }
+    }
+    let newTerm = nextBody;
+    for (let i = groups.length - 1; i >= 0; i--) {
+        const group = groups[i];
+        if (group.length === 1) {
+            newTerm = new IRApp(new IRFunc(group, newTerm), paramToArg[group[0]]);
+        }
+        else if (group.length <= 0)
+            continue;
+        else {
+            newTerm = new IRCase(new IRConstr(0, group.map(p => paramToArg[p])), [new IRFunc(group, newTerm)]);
+        }
+    }
+    if (parent)
+        _modifyChildFromTo(parent, root, newTerm);
+    else
+        root = newTerm;
+    return {
+        newRoot: !parent ? root : undefined,
+        args: sortedArgs,
+        nextBody
+    };
+}

package/dist/IR/toUPLC/subRoutines/performUplcOptimizationsAndReturnRoot/performUplcOptimizationsAndReturnRoot.js

@@ -89,6 +89,10 @@ function groupIndependentApplications(root) {
     if (!(func instanceof IRFunc))
         return undefined;
     const params = func.params.slice();
+    // Separate excess outer args: getApplicationTerms may return more args
+    // than func.params (e.g. `(λp. body)(arg1)(arg2)` → 2 args, 1 param).
+    // Excess args are trailing applications applied after all param bindings.
+    const trailingArgs = args.splice(params.length);
     while (true) {
         applicaitonTerms = getApplicationTerms(func.body);
         if (!applicaitonTerms)
@@ -96,14 +100,20 @@ function groupIndependentApplications(root) {
         if (!(applicaitonTerms.func instanceof IRFunc))
             break;
         func = applicaitonTerms.func;
+        const nNewParams = func.params.length;
+        const innerArgs = applicaitonTerms.args;
         params.push(...func.params);
-        args.push(...applicaitonTerms.args);
+        args.push(...innerArgs.slice(0, nNewParams));
+        // Inner excess args are applied before outer excess args
+        if (innerArgs.length > nNewParams) {
+            trailingArgs.unshift(...innerArgs.slice(nNewParams));
+        }
         if (params.length !== args.length)
             break;
     }
     const len = Math.min(params.length, args.length);
     const finalParams = params.slice(len);
-    const finalArgs = args.slice(len);
+    const finalArgs = [...args.slice(len), ...trailingArgs];
     params.length = len;
     args.length = len;
     const paramToArg = {};

package/dist/compiler/Compiler.js

@@ -64,7 +64,7 @@ export class Compiler extends DiagnosticEmitter {
         // backend starts here
         const ir = compileTypedProgram(cfg, program);
         const uplc = compileIRToUPLC(ir, cfg);
-        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc)).toBuffer().buffer;
+        const serialized = compileUPLC(new UPLCProgram(cfg.targetUplcVersion, uplc));
         const outDir = cfg.outDir;
         const outPath = outDir + (outDir.endsWith("/") ? "" : "/") + "out.flat";
         this.io.writeFile(outPath, serialized, cfg.root);

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

@@ -117,7 +117,7 @@ export class TirNativeFunc {
             int_t
         ], bool_t));
     }
-    // ByteString operations
+    // bytes operations
     static get appendByteString() {
         return new TirNativeFunc(IRNativeTag.appendByteString, new TirFuncT([
             // left
@@ -512,7 +512,7 @@ export class TirNativeFunc {
             bytes_t
         ], bytes_t));
     }
-    // ByteString manipulation
+    // bytes manipulation
     static get integerToByteString() {
         return new TirNativeFunc(IRNativeTag.integerToByteString, new TirFuncT([
             // flag
@@ -585,7 +585,7 @@ export class TirNativeFunc {
             bool_t
         ], bytes_t));
     }
-    // Additional ByteString operations
+    // Additional bytes operations
     static get replicateByte() {
         return new TirNativeFunc(IRNativeTag.replicateByte, new TirFuncT([
             // count

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-export * from "@harmoniclabs/bytestring";
 export * from "@harmoniclabs/cbor";
 export * from "@harmoniclabs/obj-utils";
-export * from "@harmoniclabs/pair";
 export * from "@harmoniclabs/plutus-data";
 export * from "@harmoniclabs/plutus-machine";
 export * from "@harmoniclabs/uint8array-utils";

package/dist/index.js

@@ -1,7 +1,5 @@
-export * from "@harmoniclabs/bytestring";
 export * from "@harmoniclabs/cbor";
 export * from "@harmoniclabs/obj-utils";
-export * from "@harmoniclabs/pair";
 export * from "@harmoniclabs/plutus-data";
 export * from "@harmoniclabs/plutus-machine";
 export * from "@harmoniclabs/uint8array-utils";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.3-dev0",
+  "version": "0.1.3-dev1",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -51,25 +51,22 @@
   "homepage": "https://github.com/HarmonicLabs/pebble#readme",
   "dependencies": {
     "@harmoniclabs/bigint-utils": "^1.0.0",
-    "@harmoniclabs/bytestring": "^1.0.0",
-    "@harmoniclabs/cbor": "^1.6.6",
+    "@harmoniclabs/cardano-costmodels-ts": "^1.4.0",
+    "@harmoniclabs/cbor": "^2.0.1",
     "@harmoniclabs/crypto": "^0.3.0",
     "@harmoniclabs/obj-utils": "^1.0.0",
-    "@harmoniclabs/pair": "^1.0.0",
-    "@harmoniclabs/plutus-data": "^1.2.6",
-    "@harmoniclabs/plutus-machine": "^2.1.1",
+    "@harmoniclabs/plutus-data": "^2.0.1",
+    "@harmoniclabs/plutus-machine": "^3.0.0",
     "@harmoniclabs/uint8array-utils": "^1.0.4",
-    "@harmoniclabs/uplc": "^1.4.1"
+    "@harmoniclabs/uplc": "^2.0.5"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.18.6",
     "@babel/preset-typescript": "^7.18.6",
-    "@harmoniclabs/cardano-costmodels-ts": "^1.3.0",
-    "@harmoniclabs/cardano-ledger-ts": "^0.3.2",
     "@types/jest": "^28.1.4",
     "@types/node": "^18.14.6",
     "jest": "^29.4.3",
-    "jest-environment-jsdom": "^29.4.3",
+    "jest-environment-jsdom": "^30.3.0",
     "tsc-alias": "^1.7.1",
     "typescript": "^4.6.3"
   },