@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,161 +0,0 @@
-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) {
-    // unwrap;
-    // if( term instanceof IRHoisted )
-    while (term instanceof IRHoisted) {
-        // we know `handleHoistedAndReturnRoot` modifies the term
-        // so we are probably ok not cloning here
-        // top level hoisted terms should be handled in `compileIRToUPLC` anyway
-        term = term.hoisted;
-        // we still need to remove this parent otherhwise there will be an unknown hoisted to handle
-        term.parent = undefined;
-        // return handleHoistedAndReturnRoot(
-        //     theTerm
-        // );
-    }
-    // TODO: should probably merge `markRecursiveHoistsAsForced` inside `getHoistedTerms` to iter once
-    markRecursiveHoistsAsForced(term);
-    const directHoisteds = getHoistedTerms(term);
-    const allHoisteds = getSortedHoistedSet(directHoisteds);
-    let n = allHoisteds.length;
-    // evaluating constants
-    if (n === 0) {
-        return term;
-    }
-    // nothing to do; shortcut.
-    if (n === 0)
-        return term;
-    let a = 0;
-    let b = 0;
-    const toHoist = new Array(n);
-    const toInline = new Array(n);
-    // filter out hoisted terms with single reference
-    for (let i = 0; i < n; i++) {
-        const thisHoistedEntry = allHoisteds[i];
-        if (thisHoistedEntry.hoisted.meta.forceHoist === true) {
-            toHoist[a++] = thisHoistedEntry.hoisted;
-            continue;
-        }
-        if (thisHoistedEntry.nReferences === 1 &&
-            thisHoistedEntry.hoisted.parent) {
-            // inline hoisted with single reference
-            toInline[b++] = thisHoistedEntry.hoisted;
-        }
-        else
-            toHoist[a++] = thisHoistedEntry.hoisted;
-    }
-    // drop unused space
-    toHoist.length = a;
-    toInline.length = b;
-    const hoistedsToInlineHashes = toInline.map(h => h.hash);
-    // console.log( "toHoist", toHoist.map( h => ({ ...showIR( h.hoisted ), hash: toHex( h.hash ) }) ) );
-    // console.log( "toInline", toInline.map( h => ({ ...showIR( h.hoisted ), hash: toHex( h.hash ) }) ) );
-    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());
-    }
-    // replace hoisted references with variables
-    const stack = [{ irTerm: root, dbn: 0 }];
-    while (stack.length > 0) {
-        const { irTerm, dbn } = stack.pop();
-        const irTermHash = irTerm.hash;
-        const isHoistedToinline = hoistedsToInlineHashes.some(h => equalIrHash(h, irTermHash));
-        if (
-        // is hoiseted
-        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}`);
-            }
-            // 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
-            });
-            // don't push anything
-            // because we just replaced with a variable
-            // so we know there's not a tree to explore
-            continue;
-        }
-        else if (irTerm instanceof IRHoisted) {
-            if (!isHoistedToinline) {
-                throw new Error("unexpected hoisted term found with hash: " + irHashToHex(irTermHash) +
-                    "\n showIR of the term: " + stringify(showIR(irTerm), undefined, 2));
-            }
-            const toInline = irTerm.hoisted;
-            _modifyChildFromTo(irTerm.parent, irTerm, toInline);
-            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) {
-            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;
-        }
-    }
-    return root;
-}

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

@@ -1,5 +0,0 @@
-import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
-import { IRTerm } from "../../../IRTerm.js";
-import { IRApp } from "../../../IRNodes/index.js";
-export type RecursiveIRNode = IRRecursive | IRApp;
-export declare function findHighestRecursiveParent(term: IRTerm, maxScope: IRTerm): RecursiveIRNode | undefined;

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

@@ -1,14 +0,0 @@
-import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
-export function findHighestRecursiveParent(term, maxScope) {
-    let highest = undefined;
-    while (term.parent !== maxScope &&
-        term.parent !== undefined) {
-        if (isRecursiveNode(term))
-            highest = term;
-        term = term.parent;
-    }
-    return highest;
-}
-function isRecursiveNode(term) {
-    return (term instanceof IRRecursive);
-}

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

@@ -1,20 +0,0 @@
-import { IRFunc } from "../../../IRNodes/IRFunc.js";
-import { LettedSetEntry } from "../../../IRNodes/IRLetted.js";
-import { IRTerm } from "../../../IRTerm.js";
-type ScopedLettedTerms = {
-    maxScope: IRFunc | 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 {};

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

@@ -1,107 +0,0 @@
-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) {
-        const scopeEntry = scopes.find(entry => entry.maxScope === scope);
-        if (scopeEntry === undefined) {
-            scopes.push({
-                maxScope: scope,
-                group: [letted]
-            });
-            return;
-        }
-        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;
-            }
-        }
-        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);
-            }
-        }
-        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 });
-            continue;
-        }
-        if (term instanceof IRForced) {
-            stack.push({ term: term.forced, dbn });
-            continue;
-        }
-        if (term instanceof IRFunc) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
-            continue;
-        }
-        if (term instanceof IRRecursive) {
-            stack.push({ term: term.body, dbn: dbn + term.arity });
-            continue;
-        }
-        // letted terms do count too
-        if (term instanceof IRLetted) {
-            stack.push({ term: term.value, dbn });
-            continue;
-        }
-        // closed
-        // if( term instanceof IRHoisted )
-    }
-    return minDbn;
-}

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

@@ -1,9 +0,0 @@
-import { IRTerm } from "../../../IRTerm.js";
-import { IRLetted } from "../../../IRNodes/IRLetted.js";
-/**
- *  add 1 to every var's DeBruijn that accesses stuff outside the parent node
- *  not including the `parentNode` node
- *  since the new function introdcued substituting the letted term
- *  is added inside the `parentNode` node
-**/
-export declare function incrementUnboundDbns(theTerm: IRTerm, shouldNotModifyLetted: (letted: IRLetted, dbn: number) => boolean): void;

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

@@ -1,73 +0,0 @@
-import { IRVar } from "../../../IRNodes/IRVar.js";
-import { IRLetted } from "../../../IRNodes/IRLetted.js";
-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 { IRCase } from "../../../IRNodes/IRCase.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { IRConstr } from "../../../IRNodes/IRConstr.js";
-import { IRRecursive } from "../../../IRNodes/IRRecursive.js";
-import { IRSelfCall } from "../../../IRNodes/IRSelfCall.js";
-/**
- *  add 1 to every var's DeBruijn that accesses stuff outside the parent node
- *  not including the `parentNode` node
- *  since the new function introdcued substituting the letted term
- *  is added inside the `parentNode` node
-**/
-export function incrementUnboundDbns(theTerm, shouldNotModifyLetted) {
-    const stack = [{ term: theTerm, dbn: 0 }];
-    while (stack.length > 0) {
-        const { term: t, dbn } = stack.pop();
-        if ((t instanceof IRVar ||
-            t instanceof IRSelfCall) &&
-            t.dbn >= dbn) {
-            // there's a new variable in scope
-            t.dbn++;
-            continue;
-        }
-        if (t instanceof IRLetted) {
-            if (shouldNotModifyLetted(t, dbn)) {
-                // don't modify letted to be hoisted
-                continue;
-            }
-            else // other letted to be handled in one of the next cycles
-             {
-                // `IRLambdas` DeBruijn are tracking the level of instantiation
-                // we add a new variable so the dbn of instantiation increments
-                t.dbn += 1;
-                stack.push({ term: t.value, dbn });
-            }
-            continue;
-        }
-        if (t instanceof IRApp) {
-            stack.push({ term: t.arg, dbn }, { term: t.fn, dbn });
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push({ term: t.constrTerm, dbn }, ...mapArrayLike(t.continuations, continuation => ({ term: continuation, dbn })));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            stack.push(...mapArrayLike(t.fields, field => ({ term: field, dbn })));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push({ term: t.delayed, dbn });
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push({ term: t.forced, dbn });
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        if (t instanceof IRRecursive) {
-            stack.push({ term: t.body, dbn: dbn + t.arity });
-            continue;
-        }
-        // skip hoisted since closed
-    }
-}

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

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