@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev6

package/dist/IR/toUPLC/ctx/ToUplcCtx.js

@@ -0,0 +1,75 @@
+export class ToUplcCtx {
+    parent;
+    ctxMap;
+    _variables;
+    get _parentDbn() {
+        return this.parent?.dbn ?? 0;
+    }
+    get dbn() {
+        return this._variables.length + this._parentDbn;
+    }
+    _frozen;
+    constructor(parent, variables) {
+        this.parent = parent;
+        this.ctxMap = this.parent?.ctxMap ?? new Map();
+        this._variables = variables;
+        for (const v of variables)
+            this.ctxMap.set(v, this);
+    }
+    static root() {
+        return new ToUplcCtx(undefined, []);
+    }
+    newChild(variables) {
+        return new ToUplcCtx(this, variables);
+    }
+    getVarDeclDbn(sym) {
+        const ctx = this.ctxMap.get(sym);
+        const idx = ctx?._variables.indexOf(sym) ?? -1;
+        if (idx <= -1) {
+            console.log(sym, ctx?.allVars());
+            throw new Error("Variable not found in its defining context");
+        }
+        const declDbn = ctx._parentDbn + idx + 1;
+        if (declDbn === 5
+            && sym.description === "tailList") {
+            console.log({
+                ctxDbn: ctx.dbn,
+                idx
+            });
+        }
+        return declDbn;
+    }
+    getVarAccessDbn(sym) {
+        const declDbn = this.getVarDeclDbn(sym);
+        return this.dbn - declDbn;
+    }
+    toJson() {
+        let obj = {};
+        let prevCtx = null;
+        let ctx = this;
+        do {
+            obj["parentDbn"] = ctx._parentDbn;
+            obj["dbn"] = ctx.dbn;
+            obj["vars"] = ctx._variables.slice();
+            obj["next"] = prevCtx;
+            prevCtx = obj;
+            obj = {};
+            ctx = ctx.parent;
+        } while (ctx);
+        return prevCtx;
+    }
+    allVars() {
+        let vars = [];
+        let ctx = this;
+        while (ctx = ctx.parent) {
+            vars = ctx._variables.concat(vars);
+        }
+        return vars;
+    }
+    // for debugging purposes
+    // "inefficient" but correct way to get expected de bruijn index
+    expectedDbn(sym) {
+        const vars = this.allVars();
+        return vars.length - 1 - vars.lastIndexOf(sym);
+    }
+}

package/dist/IR/toUPLC/subRoutines/_comptimeDropN.d.ts

@@ -0,0 +1,8 @@
+import { IRHoisted, IRNative } from "../../IRNodes/index.js";
+export declare const hoisted_drop2: IRHoisted;
+export declare const hoisted_drop3: IRHoisted;
+export declare const hoisted_drop4: IRHoisted;
+export declare const hoisted_drop8: IRHoisted;
+export declare const hoisted_drop16: IRHoisted;
+export declare const hoisted_drop32: IRHoisted;
+export declare function _compTimeDropN(bigN: bigint): IRHoisted | IRNative;

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

@@ -0,0 +1,95 @@
+import { IRHoisted, IRFunc, IRNative, IRVar, _ir_apps } from "../../IRNodes/index.js";
+const tailList = new IRHoisted(IRNative.tailList);
+tailList.hash;
+const drop2_lst = Symbol("lst");
+export const hoisted_drop2 = new IRHoisted(new IRFunc([drop2_lst], // lst
+_ir_apps(tailList.clone(), _ir_apps(tailList.clone(), new IRVar(drop2_lst) // lst
+))));
+hoisted_drop2.hash;
+const drop3_lst = Symbol("lst");
+export const hoisted_drop3 = new IRHoisted(new IRFunc([drop3_lst], // lst
+_ir_apps(tailList.clone(), _ir_apps(tailList.clone(), _ir_apps(tailList.clone(), new IRVar(drop3_lst) // lst
+)))));
+hoisted_drop3.hash;
+const drop4_lst = Symbol("lst");
+export const hoisted_drop4 = new IRHoisted(new IRFunc([drop4_lst], // lst
+_ir_apps(tailList.clone(), _ir_apps(tailList.clone(), _ir_apps(tailList.clone(), _ir_apps(tailList.clone(), new IRVar(drop4_lst) // lst
+))))));
+hoisted_drop4.hash;
+const drop8_lst = Symbol("lst");
+export const hoisted_drop8 = new IRHoisted(new IRFunc([drop8_lst], // lst
+_ir_apps(hoisted_drop4.clone(), _ir_apps(hoisted_drop4.clone(), new IRVar(drop8_lst) // lst
+))));
+hoisted_drop8.hash;
+// replace numeric arity version of drop16 with symbol param
+const drop16_lst = Symbol("lst");
+export const hoisted_drop16 = new IRHoisted(new IRFunc([drop16_lst], _ir_apps(hoisted_drop8.clone(), _ir_apps(hoisted_drop8.clone(), new IRVar(drop16_lst)))));
+hoisted_drop16.hash;
+// replace numeric arity version of drop32 with symbol param
+const drop32_lst = Symbol("lst");
+export const hoisted_drop32 = new IRHoisted(new IRFunc([drop32_lst], _ir_apps(hoisted_drop16.clone(), _ir_apps(hoisted_drop16.clone(), new IRVar(drop32_lst)))));
+hoisted_drop32.hash;
+export function _compTimeDropN(bigN) {
+    const n = Number(bigN);
+    if (n < 0)
+        throw new Error(`Cannot drop a negative number of elements from a list`);
+    if (n === 0)
+        return IRNative._id;
+    if (n === 1)
+        return tailList.clone();
+    if (n === 2)
+        return hoisted_drop2;
+    if (n === 3)
+        return hoisted_drop3;
+    if (n === 4)
+        return hoisted_drop4;
+    if (n === 8)
+        return hoisted_drop8;
+    if (n === 16)
+        return hoisted_drop16;
+    if (n === 32)
+        return hoisted_drop32;
+    // Greedy decomposition into available drop sizes (largest first)
+    let remaining = n;
+    const parts = [];
+    const sizes = [32, 16, 8, 4, 3, 2, 1];
+    for (const s of sizes) {
+        while (remaining >= s) {
+            parts.push(s);
+            remaining -= s;
+        }
+        if (remaining === 0)
+            break;
+    }
+    // Build the composed drop function body by sequential application
+    const lst = Symbol("lst"); // symbol param for composed function
+    let body = new IRVar(lst);
+    for (const p of parts) {
+        switch (p) {
+            case 32:
+                body = _ir_apps(hoisted_drop32.clone(), body);
+                break;
+            case 16:
+                body = _ir_apps(hoisted_drop16.clone(), body);
+                break;
+            case 8:
+                body = _ir_apps(hoisted_drop8.clone(), body);
+                break;
+            case 4:
+                body = _ir_apps(hoisted_drop4.clone(), body);
+                break;
+            case 3:
+                body = _ir_apps(hoisted_drop3.clone(), body);
+                break;
+            case 2:
+                body = _ir_apps(hoisted_drop2.clone(), body);
+                break;
+            case 1:
+                body = _ir_apps(tailList.clone(), body);
+                break;
+        }
+    }
+    const hoisted = new IRHoisted(new IRFunc([lst], body));
+    hoisted.hash;
+    return hoisted;
+}

package/dist/IR/toUPLC/subRoutines/handleHoistedAndReturnRoot/index.js

@@ -1,17 +1,11 @@
 import { IRApp } from "../../../IRNodes/IRApp.js";
-import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IRNodes/IRForced.js";
 import { IRFunc } from "../../../IRNodes/IRFunc.js";
 import { getSortedHoistedSet, getHoistedTerms, IRHoisted } from "../../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../../IRNodes/IRLetted.js";
 import { IRVar } from "../../../IRNodes/IRVar.js";
 import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
 import { showIR } from "../../../utils/showIR.js";
 import { markRecursiveHoistsAsForced } from "../markRecursiveHoistsAsForced.js";
 import { equalIrHash, irHashToHex } from "../../../IRHash.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
 import { stringify } from "../../../../utils/stringify.js";
 import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
 export function handleHoistedAndReturnRoot(term) {
@@ -68,19 +62,11 @@ export function handleHoistedAndReturnRoot(term) {
     let root = term;
     while (root.parent !== undefined)
         root = root.parent;
-    function getIRVarForHoistedAtLevel(_hoistedHash, level) {
-        let levelOfTerm = toHoist.findIndex(sortedH => equalIrHash(sortedH.hash, _hoistedHash));
-        if (levelOfTerm < 0) {
-            throw new Error(`missing hoisted with hash ${irHashToHex(_hoistedHash)} between toHoist [\n\t${toHoist.map(h => irHashToHex(h.hash))
-                .join(",\n\t")}\n]; can't replace with IRVar`);
-        }
-        return new IRVar(level - (levelOfTerm + 1));
-    }
     // adds the actual terms
     // from last to first
     for (let i = toHoist.length - 1; i >= 0; i--) {
         const thisHoisted = toHoist[i];
-        root = new IRApp(new IRFunc(1, root), thisHoisted.hoisted.clone());
+        root = new IRApp(new IRFunc([thisHoisted.name], root), thisHoisted.hoisted.clone());
     }
     // replace hoisted references with variables
     const stack = [{ irTerm: root, dbn: 0 }];
@@ -93,22 +79,14 @@ export function handleHoistedAndReturnRoot(term) {
         irTerm instanceof IRHoisted &&
             // is not one to be inlined
             !isHoistedToinline) {
-            const irvar = getIRVarForHoistedAtLevel(irTermHash, dbn);
-            if (irvar.dbn >= dbn) {
-                throw new Error(`out of bound hoisted term; hash: ${irHashToHex(irTerm.hash)}; var's DeBruijn: ${irvar.dbn} (starts from 0); tot hoisted in scope: ${dbn}`);
-            }
+            const irvar = new IRVar(irTerm.name); // getIRVarForHoistedAtLevel( irTermHash, dbn );
             // console.log(
             //     showIRText( irTerm.parent as IRTerm ),
             //     "\n\n",
             //     showIRText( irTerm ),
             // )
             _modifyChildFromTo(irTerm.parent, irTerm, irvar);
-            Object.defineProperty(irTerm.meta, "handled", {
-                value: true,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
+            irTerm.meta.handled = true;
             // don't push anything
             // because we just replaced with a variable
             // so we know there's not a tree to explore
@@ -124,38 +102,13 @@ export function handleHoistedAndReturnRoot(term) {
             stack.push({ irTerm: toInline, dbn });
             continue;
         }
-        if (irTerm instanceof IRApp) {
-            stack.push({ irTerm: irTerm.fn, dbn }, { irTerm: irTerm.arg, dbn });
-            continue;
-        }
-        if (irTerm instanceof IRCase) {
-            stack.push({ irTerm: irTerm.constrTerm, dbn }, ...mapArrayLike(irTerm.continuations, (continuation) => ({ irTerm: continuation, dbn })));
-            continue;
-        }
-        if (irTerm instanceof IRConstr) {
-            stack.push(...mapArrayLike(irTerm.fields, (field) => ({ irTerm: field, dbn })));
-            continue;
-        }
-        if (irTerm instanceof IRDelayed) {
-            stack.push({ irTerm: irTerm.delayed, dbn });
-            continue;
-        }
-        if (irTerm instanceof IRForced) {
-            stack.push({ irTerm: irTerm.forced, dbn });
-            continue;
-        }
-        if (irTerm instanceof IRFunc) {
+        if (irTerm instanceof IRFunc
+            || irTerm instanceof IRRecursive) {
             stack.push({ irTerm: irTerm.body, dbn: dbn + irTerm.arity });
             continue;
         }
-        if (irTerm instanceof IRRecursive) {
-            stack.push({ irTerm: irTerm.body, dbn: dbn + irTerm.arity });
-            continue;
-        }
-        if (irTerm instanceof IRLetted) {
-            stack.push({ irTerm: irTerm.value, dbn });
-            continue;
-        }
+        stack.push(...irTerm.children()
+            .map(child => ({ irTerm: child, dbn })));
     }
     return root;
 }

package/dist/IR/toUPLC/subRoutines/handleLetted/groupByScope.d.ts

@@ -1,20 +1,13 @@
-import { IRFunc } from "../../../IRNodes/IRFunc.js";
 import { LettedSetEntry } from "../../../IRNodes/IRLetted.js";
+import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
+import { IRVar } from "../../../IRNodes/IRVar.js";
 import { IRTerm } from "../../../IRTerm.js";
 type ScopedLettedTerms = {
-    maxScope: IRFunc | undefined;
+    maxScope: IRTerm | undefined;
     group: LettedSetEntry[];
 };
 export declare function groupByScope(letteds: LettedSetEntry[]): ScopedLettedTerms[];
-/**
- *
- * @param _term
- * @returns {number | undefined}
- *  a `number` if the `_term` param is open;
- *  represents the debuijn index an `IRVar` would have
- *  in order to point to the smallest scope that fulfills the term;
- *
- *  `undefined` if the term is closed
- */
-export declare function _getMinUnboundDbn(_term: IRTerm): number | undefined;
+export declare function getMaxScope(term: IRTerm): IRTerm | undefined;
+export declare function getUnboundedIRVars(term: IRTerm): (IRVar | IRSelfCall)[];
+export declare function getUnboundedVars(term: IRTerm, knownVars?: Set<symbol> | undefined): Set<symbol>;
 export {};

package/dist/IR/toUPLC/subRoutines/handleLetted/groupByScope.js

@@ -1,14 +1,8 @@
-import { IRApp } from "../../../IRNodes/IRApp.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
 import { IRDelayed } from "../../../IRNodes/IRDelayed.js";
-import { IRForced } from "../../../IRNodes/IRForced.js";
 import { IRFunc } from "../../../IRNodes/IRFunc.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 { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
 export function groupByScope(letteds) {
     const scopes = [];
     function pushScope(scope, letted) {
@@ -23,85 +17,87 @@ export function groupByScope(letteds) {
         scopeEntry.group.push(letted);
     }
     for (const { letted, nReferences } of letteds) {
-        let minUnboundDbn = _getMinUnboundDbn(letted.value);
-        if (minUnboundDbn === undefined) {
-            pushScope(undefined, { letted, nReferences });
-            continue;
-        }
-        let maxScope = letted.parent;
-        if (maxScope instanceof IRFunc ||
-            maxScope instanceof IRRecursive) {
-            minUnboundDbn -= maxScope.arity;
-        }
-        while (minUnboundDbn >= 0) {
-            maxScope = maxScope?.parent;
-            if (maxScope instanceof IRFunc ||
-                maxScope instanceof IRRecursive) {
-                minUnboundDbn -= maxScope.arity;
-            }
-        }
+        const maxScope = getMaxScope(letted.value);
         pushScope(maxScope, { letted, nReferences });
     }
     return scopes;
 }
-/**
- *
- * @param _term
- * @returns {number | undefined}
- *  a `number` if the `_term` param is open;
- *  represents the debuijn index an `IRVar` would have
- *  in order to point to the smallest scope that fulfills the term;
- *
- *  `undefined` if the term is closed
- */
-export function _getMinUnboundDbn(_term) {
-    let minDbn = undefined;
-    const stack = [{ term: _term, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term, dbn } = stack.pop();
-        if (term instanceof IRVar ||
-            term instanceof IRSelfCall) {
-            if (term.dbn >= dbn) // some val outside
-             {
-                const outsideDbn = term.dbn - dbn;
-                minDbn = minDbn === undefined ? outsideDbn : Math.min(outsideDbn, minDbn);
+export function getMaxScope(term) {
+    const unbounded = getUnboundedVars(term);
+    if (unbounded.size === 0)
+        return undefined;
+    while (term.parent) {
+        term = term.parent;
+        if (term instanceof IRDelayed)
+            return term;
+        if (term instanceof IRFunc
+            || term instanceof IRRecursive) {
+            for (const param of term.params) {
+                if (unbounded.has(param))
+                    return term;
             }
         }
-        if (term instanceof IRApp) {
-            stack.push({ term: term.fn, dbn }, { term: term.arg, dbn });
-            continue;
-        }
-        if (term instanceof IRCase) {
-            stack.push({ term: term.constrTerm, dbn }, ...mapArrayLike(term.continuations, continuation => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (term instanceof IRConstr) {
-            stack.push(...mapArrayLike(term.fields, field => ({ term: field, dbn })));
-            continue;
-        }
-        if (term instanceof IRDelayed) {
-            stack.push({ term: term.delayed, dbn });
+    }
+    throw new Error("Unbounded var not found in any parent term");
+}
+export function getUnboundedIRVars(term) {
+    const accessedVars = new Map();
+    const boundedVars = new Set();
+    const stack = [term];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRVar
+            || t instanceof IRSelfCall) {
+            let vars = accessedVars.get(t.name);
+            if (!Array.isArray(vars)) {
+                vars = [];
+                accessedVars.set(t.name, vars);
+            }
+            vars.push(t);
             continue;
         }
-        if (term instanceof IRForced) {
-            stack.push({ term: term.forced, dbn });
+        if (t instanceof IRFunc
+            || t instanceof IRRecursive) {
+            for (const param of t.params)
+                boundedVars.add(param);
+            stack.push(t.body);
             continue;
         }
-        if (term instanceof IRFunc) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
-            continue;
+        stack.push(...t.children());
+    }
+    console.log("accessedVars", [...new Set(accessedVars.keys())]);
+    console.log("boundedVars", [...boundedVars]);
+    for (const v of boundedVars)
+        accessedVars.delete(v);
+    return [...accessedVars.values()].flat();
+}
+export function getUnboundedVars(term, knownVars) {
+    const accessedVars = new Set();
+    const boundedVars = new Set();
+    if (knownVars instanceof Set) {
+        for (const v of knownVars) {
+            if (typeof v === "symbol")
+                boundedVars.add(v);
         }
-        if (term instanceof IRRecursive) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
+    }
+    const stack = [term];
+    while (stack.length > 0) {
+        const t = stack.pop();
+        if (t instanceof IRVar
+            || t instanceof IRSelfCall) {
+            accessedVars.add(t.name);
             continue;
         }
-        // letted terms do count too
-        if (term instanceof IRLetted) {
-            stack.push({ term: term.value, dbn });
+        if (t instanceof IRFunc
+            || t instanceof IRRecursive) {
+            for (const param of t.params)
+                boundedVars.add(param);
+            stack.push(t.body);
             continue;
         }
-        // closed
-        // if( term instanceof IRHoisted )
+        stack.push(...t.children());
     }
-    return minDbn;
+    for (const v of boundedVars)
+        accessedVars.delete(v);
+    return accessedVars;
 }