@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,227 +0,0 @@
-import { IRConstr, IRNative } from "../../../IRNodes/index.js";
-import { IRApp } from "../../../IRNodes/IRApp.js";
-import { IRCase } from "../../../IRNodes/IRCase.js";
-import { IRDelayed } from "../../../IRNodes/IRDelayed.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 { dependsByDbns } from "../../../IRNodes/utils/dependsByDbns.js";
-import { mapArrayLike } from "../../../IRNodes/utils/mapArrayLike.js";
-import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
-import { isDebugUplcOptimizations } from "../../CompilerOptions.js";
-import { expandFuncsAndReturnRoot, getExpandedIRFunc } from "./expandFuncsAndReturnRoot.js";
-export function performUplcOptimizationsAndReturnRoot(root, options) {
-    const opts = options.uplcOptimizations;
-    if (isDebugUplcOptimizations(opts))
-        return root;
-    const { groupApplications, inlineSingleUse, simplifyWrappedPartialFuncApps, removeForceDelay } = opts;
-    root = expandFuncsAndReturnRoot(root);
-    const stack = [[root, 0]];
-    while (stack.length > 0) {
-        let [t, dbn] = stack.pop();
-        if (t instanceof IRApp) {
-            if (isIdLike(t.fn)) {
-                if (t.parent)
-                    _modifyChildFromTo(t.parent, t, t.arg);
-                else
-                    root = t.arg;
-                stack.push([t.arg, dbn]);
-                continue;
-            }
-            if (!groupApplications) {
-                stack.push([t.fn, dbn], [t.arg, dbn]);
-                continue;
-            }
-            let args;
-            let body;
-            /*
-            // can't figure how to make it work
-            [ args, body ] = groupIndipendentLets( t, dbn );
-
-            if( args.length >= 2 )
-            {
-                let newNode = body;
-                for( let i = args.length - 1; i >= 0; i-- )
-                {
-                    // apply as normal apps, not case/constr
-                    // so we can further group if the body is directly applications
-                    newNode = new IRApp( newNode, args[i] );
-                }
-
-                // overwrite original
-                if( t.parent ) _modifyChildFromTo( t.parent, t, newNode );
-                else root = newNode;
-
-                // reanalyze this new node to group using case/constr
-                stack.push([ newNode, dbn ]);
-                continue;
-            }
-            //*/
-            [args, body] = getMultiAppArgsAndBody(t);
-            if (args.length <= 2) {
-                stack.push([t.fn, dbn], [t.arg, dbn]);
-                continue;
-            }
-            const newNode = new IRCase(new IRConstr(0, args), [body]);
-            stack.push([body, dbn]);
-            if (t.parent)
-                _modifyChildFromTo(t.parent, t, newNode);
-            else
-                root = newNode;
-            continue;
-        }
-        if (t instanceof IRCase) {
-            stack.push([t.constrTerm, dbn], ...mapArrayLike(t.continuations, (c) => [c, dbn]));
-            continue;
-        }
-        if (t instanceof IRConstr) {
-            // stack.push( ...t.fields );
-            stack.push(...mapArrayLike(t.fields, (f) => [f, dbn]));
-            continue;
-        }
-        if (t instanceof IRDelayed) {
-            stack.push([t.delayed, dbn]);
-            continue;
-        }
-        if (t instanceof IRForced) {
-            stack.push([t.forced, dbn]);
-            continue;
-        }
-        if (t instanceof IRFunc) {
-            stack.push([t.body, dbn + t.arity]);
-            continue;
-        }
-        if (t instanceof IRRecursive ||
-            t instanceof IRHoisted ||
-            t instanceof IRLetted ||
-            t instanceof IRSelfCall) {
-            throw new Error("Unexpected term while performing uplc optimizations");
-        }
-    }
-    return root;
-}
-function isAppLike(term) {
-    return (term instanceof IRApp ||
-        isCaseConstrApp(term));
-}
-/** @experimental still can't figure how to make it work */
-export function groupIndipendentLets(term, dbn) {
-    let args = [];
-    let body = term;
-    //*
-    const lettedDbns = [];
-    while (term instanceof IRApp &&
-        term.fn instanceof IRFunc &&
-        term.fn.arity === 1) {
-        // letted terms
-        // [(lam a [(lam b [(lam c ... ))) c] b] a] :: []
-        // [(lam b [(lam c ... ))) c] b] :: [a]
-        // [(lam c ... ) c] :: [a, b]
-        // ... :: [a, b, c]
-        // finally expand:
-        // (lam a (lam b (lam c ... ))) :: [a, b, c]
-        // console.log({
-        //     arg: prettyIRInline( term.arg ),
-        //     lettedDbns,
-        //     depends: dependsByDbns( term.arg, lettedDbns ),
-        //     currArgsLen: args.length
-        // });
-        if (!dependsByDbns(term.arg, lettedDbns)) {
-            args.push(term.arg);
-            term = term.fn.body;
-            // push current dbn
-            // and increment later
-            lettedDbns.push(dbn++);
-            body = term;
-            continue;
-        }
-        else {
-            term = term.fn.body;
-            break;
-        }
-        continue;
-    }
-    return [
-        args,
-        getExpandedIRFunc(body, args.length)
-    ];
-    //*/
-}
-function getMultiAppArgsAndBody(term) {
-    let args = [];
-    let body = term;
-    // else we look for consecutive applications or cases
-    while (term instanceof IRApp) {
-        /*
-        consecutive applications look like:
-        [
-            [
-                [
-                    (lam a (lam b (lam c ... )))
-                a]
-            b]
-        c]
-        but the equivalent IRCase looks like:
-        (case
-            (constr 0 a b c)
-            (lam a (lam b (lam c ... )))
-        )
-        so we need to reverse the order of the args
-        since we start from the outermost application
-        (in order, we encounter from the top: c => b => a)
-        */
-        args.unshift(term.arg);
-        term = term.fn;
-        // arity++;
-        body = term;
-    }
-    ;
-    return [args, body];
-    // if( args.length === 0 ) return [ args, body ];
-    // const [ nextArgs, nextBody ] = getMultiAppArgsAndBody( body, dbn );
-    // return [ args.concat( nextArgs ), nextBody ];
-}
-function isCaseConstrApp(term) {
-    return (term instanceof IRCase &&
-        term.continuations.length === 1 &&
-        term.constrTerm instanceof IRCase);
-}
-function isIdLike(term) {
-    return (term instanceof IRFunc &&
-        term.arity === 1 &&
-        term.body instanceof IRVar &&
-        Number(term.body.dbn) === 0);
-}
-function getArityOfTerm(term) {
-    let arity = 0;
-    while (term instanceof IRApp ||
-        term instanceof IRFunc ||
-        term instanceof IRNative ||
-        term instanceof IRVar ||
-        term instanceof IRForced ||
-        term instanceof IRDelayed) {
-        if (term instanceof IRForced) {
-            term = term.forced;
-            continue;
-        }
-        if (term instanceof IRDelayed) {
-            term = term.delayed;
-            continue;
-        }
-        if (term instanceof IRApp) {
-            arity--;
-            term = term.fn;
-            continue;
-        }
-        if (term instanceof IRFunc) {
-            arity += term.arity;
-            term = term.body;
-            continue;
-        }
-    }
-    return arity;
-}

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

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

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

@@ -1,13 +0,0 @@
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { isClosedIRTerm } from "../../utils/isClosedIRTerm.js";
-import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-import { iterTree } from "../_internal/iterTree.js";
-export function replaceClosedLettedWithHoisted(root) {
-    iterTree(root, (node) => {
-        if (node instanceof IRLetted && isClosedIRTerm(node.value)) {
-            _modifyChildFromTo(node.parent, node, new IRHoisted(node.value, node.meta));
-            return true;
-        }
-    });
-}

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

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

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

@@ -1,11 +0,0 @@
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { isForcedNative } from "../../IRNodes/IRNative/isForcedNative.js";
-import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-import { iterTree } from "../_internal/iterTree.js";
-export function replaceForcedNativesWithHoisted(term) {
-    iterTree(term, (node, _dbn) => {
-        if (isForcedNative(node)) {
-            _modifyChildFromTo(node.parent, node, new IRHoisted(node));
-        }
-    });
-}

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

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

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

@@ -1,16 +0,0 @@
-import { IRHoisted } from "../../IRNodes/IRHoisted.js";
-import { IRLetted } from "../../IRNodes/IRLetted.js";
-import { _modifyChildFromTo } from "../_internal/_modifyChildFromTo.js";
-import { findAll } from "../_internal/findAll.js";
-export function replaceHoistedWithLetted(term) {
-    const allHoisted = findAll(term, node => node instanceof IRHoisted);
-    for (const hoisted of allHoisted) {
-        const parent = hoisted.parent;
-        const letted = new IRLetted(0x0fffffff, // doesn't matter since closed term
-        hoisted.hoisted, { isClosed: true });
-        letted.hash; // precompute
-        // replace hoisted with letted
-        _modifyChildFromTo(parent, hoisted, letted);
-    }
-    // sanifyTree( term );
-}

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

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

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

@@ -1,16 +0,0 @@
-import { IRNative } from "../../../IRNodes/IRNative/index.js";
-import { _modifyChildFromTo } from "../../_internal/_modifyChildFromTo.js";
-import { iterTree } from "../../_internal/iterTree.js";
-import { nativeToIR } from "./nativeToIR.js";
-export function replaceNativesAndReturnRoot(tree) {
-    if (tree instanceof IRNative) {
-        return nativeToIR(tree);
-    }
-    iterTree(tree, elem => {
-        if (elem instanceof IRNative && elem.tag < 0) {
-            _modifyChildFromTo(elem.parent, elem, nativeToIR(elem));
-            return true;
-        }
-    });
-    return tree;
-}

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

@@ -1,3 +0,0 @@
-import { IRNative } from "../../../IRNodes/IRNative/index.js";
-import { IRTerm } from "../../../IRTerm.js";
-export declare function nativeToIR(native: IRNative): IRTerm;