@harmoniclabs/pebble 0.1.0-dev0

package/dist/IR/tree_utils/getChildren.js

@@ -0,0 +1,33 @@
+import { IRCase } from "../IRNodes/IRCase.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 { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRLetted } from "../IRNodes/IRLetted.js";
+import { IRConstr } from "../IRNodes/IRConstr.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+export function getChildren(term) {
+    if (term instanceof IRApp)
+        return [term.fn, term.arg];
+    if (term instanceof IRCase)
+        return [term.constrTerm, ...term.continuations];
+    if (term instanceof IRConstr)
+        return [...term.fields];
+    if (term instanceof IRFunc)
+        return [term.body];
+    if (term instanceof IRRecursive)
+        return [term.body];
+    if (term instanceof IRDelayed)
+        return [term.delayed];
+    if (term instanceof IRForced)
+        return [term.forced];
+    if (term instanceof IRHoisted)
+        return [term.hoisted];
+    if (term instanceof IRLetted)
+        return [term.value];
+    // term
+    // IRVar | IRConst | IRNative | IRError | IRSelfCall
+    // none have children
+    return [];
+}

package/dist/IR/tree_utils/getRoot.d.ts

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

package/dist/IR/tree_utils/getRoot.js

@@ -0,0 +1,6 @@
+export function getRoot(node) {
+    let root = node;
+    while (root.parent)
+        root = root.parent;
+    return root;
+}

package/dist/IR/utils/MutArrayLike.d.ts

@@ -0,0 +1,5 @@
+export interface MutArrayLike<T> {
+    readonly length: number;
+    [n: number]: T;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/dist/IR/utils/MutArrayLike.js

@@ -0,0 +1 @@
+export {};

package/dist/IR/utils/concatUint8Arr.d.ts

@@ -0,0 +1 @@
+export declare function concatUint8Arr(...arrs: (Uint8Array | Uint32Array)[]): Uint8Array;

package/dist/IR/utils/concatUint8Arr.js

@@ -0,0 +1,11 @@
+export function concatUint8Arr(...arrs) {
+    arrs = arrs.map(arr => arr instanceof Uint8Array ? arr : new Uint8Array(arr.buffer));
+    const len = arrs.reduce((acc, arr) => acc + arr.length, 0);
+    const res = new Uint8Array(len);
+    let idx = 0;
+    for (const arr of arrs) {
+        res.set(arr, idx);
+        idx += arr.length;
+    }
+    return res;
+}

package/dist/IR/utils/equalIRTerm.d.ts

@@ -0,0 +1,12 @@
+import { IRTerm } from "../IRTerm.js";
+/**
+ * forces hash evaluation
+ */
+export declare function equalIRTermHash(a: IRTerm, b: IRTerm): boolean;
+/**
+ * only checks the hash if already present ON BOTH
+ *
+ * otherwise it assumes the terms are different and returns false
+ * (even if they might be the same)
+ */
+export declare function shallowEqualIRTermHash(a: IRTerm, b: IRTerm): boolean;

package/dist/IR/utils/equalIRTerm.js

@@ -0,0 +1,19 @@
+import { equalIrHash } from "../IRHash.js";
+/**
+ * forces hash evaluation
+ */
+export function equalIRTermHash(a, b) {
+    return a === b || equalIrHash(a.hash, b.hash);
+}
+/**
+ * only checks the hash if already present ON BOTH
+ *
+ * otherwise it assumes the terms are different and returns false
+ * (even if they might be the same)
+ */
+export function shallowEqualIRTermHash(a, b) {
+    if (a === b)
+        return true;
+    return (a.isHashPresent() && b.isHashPresent() &&
+        equalIrHash(a.hash, b.hash));
+}

package/dist/IR/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./isClosedIRTerm.js";
+export * from "./isIRTerm.js";
+export * from "./showIR.js";

package/dist/IR/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./isClosedIRTerm.js";
+export * from "./isIRTerm.js";
+export * from "./showIR.js";

package/dist/IR/utils/isClosedIRTerm.d.ts

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

package/dist/IR/utils/isClosedIRTerm.js

@@ -0,0 +1,58 @@
+import { IRConst } from "../IRNodes/IRConst.js";
+import { IRFunc } from "../IRNodes/IRFunc.js";
+import { IRApp } from "../IRNodes/IRApp.js";
+import { IRError } from "../IRNodes/IRError.js";
+import { IRNative } from "../IRNodes/IRNative/index.js";
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRLetted } from "../IRNodes/IRLetted.js";
+import { IRVar } from "../IRNodes/IRVar.js";
+import { IRForced } from "../IRNodes/IRForced.js";
+import { IRDelayed } from "../IRNodes/IRDelayed.js";
+import { IRConstr } from "../IRNodes/IRConstr.js";
+import { IRCase } from "../IRNodes/IRCase.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../IRNodes/IRSelfCall.js";
+function _isClosedIRTerm(term, dbn, parent) {
+    if (term instanceof IRVar) {
+        return term.dbn < dbn;
+    }
+    if (term instanceof IRSelfCall) {
+        return term.dbn < dbn;
+    }
+    if (term instanceof IRFunc) {
+        return _isClosedIRTerm(term.body, dbn + term.arity, term);
+    }
+    if (term instanceof IRRecursive) {
+        return _isClosedIRTerm(term.body, dbn + term.arity, term);
+    }
+    if (term instanceof IRApp) {
+        return _isClosedIRTerm(term.fn, dbn, term) && _isClosedIRTerm(term.arg, dbn, term);
+    }
+    if (term instanceof IRConstr) {
+        return Array.from(term.fields).every(f => _isClosedIRTerm(f, dbn, term));
+    }
+    if (term instanceof IRCase) {
+        return _isClosedIRTerm(term.constrTerm, dbn, term) &&
+            Array.from(term.continuations).every(cont => _isClosedIRTerm(cont, dbn, term));
+    }
+    if (term instanceof IRConst)
+        return true;
+    if (term instanceof IRError)
+        return true;
+    if (term instanceof IRNative)
+        return true;
+    if (term instanceof IRHoisted)
+        return true;
+    if (term instanceof IRLetted)
+        return _isClosedIRTerm(term.value, dbn, term);
+    if (term instanceof IRForced)
+        return _isClosedIRTerm(term.forced, dbn, term);
+    if (term instanceof IRDelayed)
+        return _isClosedIRTerm(term.delayed, dbn, term);
+    // not even an IRTerm
+    console.log(parent);
+    throw new Error("`isClosedIRTerm` called on non-IR argument");
+}
+export function isClosedIRTerm(term) {
+    return _isClosedIRTerm(term, 0);
+}

package/dist/IR/utils/isIRParentTerm.d.ts

@@ -0,0 +1,12 @@
+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 { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRLetted } from "../IRNodes/IRLetted.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import type { IRTerm } from "../IRTerm.js";
+export type IRParentTerm = IRFunc | IRApp | IRLetted | IRHoisted | IRForced | IRDelayed | IRConstr | IRCase | IRRecursive;
+export declare function isIRParentTerm<T extends IRTerm>(stuff: T | undefined): stuff is (T & IRParentTerm);

package/dist/IR/utils/isIRParentTerm.js

@@ -0,0 +1,26 @@
+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 { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRLetted } from "../IRNodes/IRLetted.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+export function isIRParentTerm(stuff) {
+    return (
+    // stuff instanceof IRVar      ||
+    // stuff instanceof IRSelfCall      ||
+    stuff instanceof IRFunc ||
+        stuff instanceof IRRecursive ||
+        stuff instanceof IRApp ||
+        // stuff instanceof IRConst    ||
+        // stuff instanceof IRNative   ||
+        stuff instanceof IRLetted ||
+        stuff instanceof IRHoisted ||
+        // stuff instanceof IRError    ||
+        stuff instanceof IRForced ||
+        stuff instanceof IRDelayed ||
+        stuff instanceof IRConstr ||
+        stuff instanceof IRCase);
+}

package/dist/IR/utils/isIRTerm.d.ts

@@ -0,0 +1,2 @@
+import type { IRTerm } from "../IRTerm.js";
+export declare function isIRTerm(stuff: any): stuff is IRTerm;

package/dist/IR/utils/isIRTerm.js

@@ -0,0 +1,30 @@
+import { IRApp } from "../IRNodes/IRApp.js";
+import { IRCase } from "../IRNodes/IRCase.js";
+import { IRConst } from "../IRNodes/IRConst.js";
+import { IRConstr } from "../IRNodes/IRConstr.js";
+import { IRDelayed } from "../IRNodes/IRDelayed.js";
+import { IRError } from "../IRNodes/IRError.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 { IRNative } from "../IRNodes/IRNative/index.js";
+import { IRRecursive } from "../IRNodes/IRRecursive.js";
+import { IRSelfCall } from "../IRNodes/IRSelfCall.js";
+import { IRVar } from "../IRNodes/IRVar.js";
+export function isIRTerm(stuff) {
+    return (stuff instanceof IRVar ||
+        stuff instanceof IRSelfCall ||
+        stuff instanceof IRFunc ||
+        stuff instanceof IRRecursive ||
+        stuff instanceof IRApp ||
+        stuff instanceof IRConst ||
+        stuff instanceof IRNative ||
+        stuff instanceof IRLetted ||
+        stuff instanceof IRHoisted ||
+        stuff instanceof IRError ||
+        stuff instanceof IRForced ||
+        stuff instanceof IRDelayed ||
+        stuff instanceof IRConstr ||
+        stuff instanceof IRCase);
+}

package/dist/IR/utils/positiveIntAsBytes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * writes the number in a new `Uint8Array` Big Endian
+ */
+export declare function positiveIntAsBytes(n: number | bigint): Uint8Array;
+export declare function positiveBigIntAsBytes(n: bigint): Uint8Array;

package/dist/IR/utils/positiveIntAsBytes.js

@@ -0,0 +1,27 @@
+import { fromHex } from "@harmoniclabs/uint8array-utils";
+/**
+ * writes the number in a new `Uint8Array` Big Endian
+ */
+export function positiveIntAsBytes(n) {
+    if (typeof n === "bigint") {
+        return positiveBigIntAsBytes(n);
+    }
+    if (!Number.isSafeInteger(n) || n < 0) {
+        console.log(n);
+        console.trace(); // some help
+        throw new Error("how did you end up here? the name of the function explicitly says 'positiveIntAsBytes'");
+    }
+    let str = n.toString(16);
+    str = str.length % 2 === 0 ? str : "0" + str;
+    return fromHex(str);
+}
+export function positiveBigIntAsBytes(n) {
+    if (n < 0 || typeof n !== "bigint") {
+        console.log(n);
+        console.trace(); // some help
+        throw new Error("how did you end up here? the name of the function explicitly says 'positiveBigIntAsBytes'");
+    }
+    let strHex = n.toString(16);
+    strHex = strHex.length % 2 === 0 ? strHex : "0" + strHex;
+    return fromHex(strHex);
+}

package/dist/IR/utils/showIR.d.ts

@@ -0,0 +1,43 @@
+import { IRLetted } from "../IRNodes/IRLetted.js";
+import { IRTerm } from "../IRTerm.js";
+import { IRHoisted } from "../IRNodes/IRHoisted.js";
+import { IRConst } from "../IRNodes/IRConst.js";
+export declare function showIRText(_ir: IRTerm): string;
+export declare function showIR(_ir: IRTerm): {
+    text: string;
+    letted: {
+        [hash: string]: string;
+    };
+    hoisted: {
+        [hash: string]: string;
+    };
+};
+export declare function prettyIRText(_ir: IRTerm, _indent?: number): string | {
+    text: string;
+    letted: {
+        [hash: string]: string;
+    };
+    hoisted: {
+        [hash: string]: string;
+    };
+};
+export type PrettiedIR = {
+    text: string;
+    letted: {
+        [hash: string]: string;
+    };
+    hoisted: {
+        [hash: string]: string;
+    };
+};
+export declare function prettyIR(_ir: IRTerm, _indent?: number): PrettiedIR;
+export interface PrettyIRJsonStrOpts {
+    text: boolean;
+    letted: boolean;
+    hoisted: boolean;
+}
+export declare function prettyIRJsonStr(ir: IRTerm, indent?: number, opts?: Partial<PrettyIRJsonStrOpts>): string;
+export declare function hoistedToStr(ir: IRHoisted): string;
+export declare function lettedToStr(ir: IRLetted): string;
+export declare function constToString(ir: IRConst): string;
+export declare function prettyIRInline(_ir: IRTerm, _indent?: number): string;