@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/IR/IRNodes/IRFunc.d.ts

@@ -0,0 +1,33 @@
+import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
+import { ToJson } from "../../utils/ToJson.js";
+import { IRTerm } from "../IRTerm.js";
+import { IHash } from "../interfaces/IHash.js";
+import { IIRParent } from "../interfaces/IIRParent.js";
+import { IRParentTerm } from "../utils/isIRParentTerm.js";
+import { BaseIRMetadata } from "./BaseIRMetadata.js";
+import { IRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+export interface IRFuncMetadata extends BaseIRMetadata {
+}
+export declare class IRFunc implements Cloneable<IRFunc>, IHash, IIRParent, ToJson {
+    readonly arity: number;
+    constructor(arity: number, body: IRTerm, func_name?: string | undefined, _unsafeHash?: IRHash);
+    static get kind(): IRNodeKind.Func;
+    get kind(): IRNodeKind.Func;
+    static get tag(): Uint8Array;
+    private _body;
+    get body(): IRTerm;
+    set body(newBody: IRTerm);
+    private _hash;
+    get hash(): IRHash;
+    isHashPresent(): boolean;
+    markHashAsInvalid(): void;
+    readonly meta: IRFuncMetadata;
+    get name(): string | undefined;
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRTerm | undefined);
+    clone(): IRFunc;
+    toJSON(): any;
+    toJson(): any;
+}

package/dist/IR/IRNodes/IRFunc.js

@@ -0,0 +1,91 @@
+import { BasePlutsError } from "../../utils/BasePlutsError.js";
+import { concatUint8Arr } from "../utils/concatUint8Arr.js";
+import { isIRTerm } from "../utils/isIRTerm.js";
+import { positiveIntAsBytes } from "../utils/positiveIntAsBytes.js";
+import { isIRParentTerm } from "../utils/isIRParentTerm.js";
+import { hashIrData, isIRHash } from "../IRHash.js";
+import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+export class IRFunc {
+    arity;
+    constructor(arity, body, func_name, _unsafeHash) {
+        if (!Number.isSafeInteger(arity) && arity >= 1)
+            throw new BasePlutsError("invalid arity for 'IRFunc'");
+        if (!isIRTerm(body))
+            throw new Error("IRFunc body argument was not an IRTerm");
+        Object.defineProperties(this, {
+            arity: {
+                value: arity,
+                writable: false,
+                enumerable: true,
+                configurable: false
+            },
+            meta: {
+                value: {
+                    name: typeof func_name === "string" ? func_name : (void 0)
+                },
+                writable: true,
+                enumerable: true,
+                configurable: false
+            }
+        });
+        this._body = body;
+        this._body.parent = this;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+        this._parent = undefined;
+    }
+    static get kind() { return IRNodeKind.Func; }
+    get kind() { return IRFunc.kind; }
+    static get tag() { return new Uint8Array([IRFunc.kind]); }
+    _body;
+    get body() { return this._body; }
+    set body(newBody) {
+        if (!isIRTerm(newBody)) {
+            throw new BasePlutsError("invalid IRTerm to be a function body");
+        }
+        if (!shallowEqualIRTermHash(this._body, newBody))
+            this.markHashAsInvalid();
+        // keep the parent reference in the old child, useful for compilation
+        // _body.parent = undefined;
+        this._body = newBody;
+        this._body.parent = this;
+    }
+    _hash;
+    get hash() {
+        if (!isIRHash(this._hash)) {
+            this._hash = hashIrData(concatUint8Arr(IRFunc.tag, positiveIntAsBytes(this.arity), this._body.hash));
+        }
+        return this._hash;
+    }
+    isHashPresent() { return isIRHash(this._hash); }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    meta;
+    get name() { return this.meta.name; }
+    ;
+    _parent;
+    get parent() { return this._parent; }
+    set parent(newParent) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        this._parent = newParent;
+    }
+    clone() {
+        return new IRFunc(this.arity, this._body.clone(), this.meta.name, this.isHashPresent() ? this.hash : undefined);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            type: "IRFunc",
+            arity: this.arity,
+            body: this._body.toJson()
+        };
+    }
+}

package/dist/IR/IRNodes/IRHoisted.d.ts

@@ -0,0 +1,55 @@
+import { IRMetadata } from "../interfaces/IRMetadata.js";
+import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
+import { ToJson } from "../../utils/ToJson.js";
+import { IRTerm } from "../IRTerm.js";
+import { IHash, IIRParent } from "../interfaces/index.js";
+import { IRParentTerm } from "../utils/isIRParentTerm.js";
+import { IRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+export type HoistedSetEntry = {
+    hoisted: IRHoisted;
+    nReferences: number;
+};
+export interface IRHoistedMeta {
+    /**
+     * force hoisting even if only a single reference is found
+     *
+     * useful to hoist terms used once in recursive expressions
+    **/
+    forceHoist?: boolean;
+    name?: string | undefined;
+}
+export interface IRHoistedMetadata extends IRMetadata {
+    meta: IRHoistedMeta;
+}
+export declare class IRHoisted implements Cloneable<IRHoisted>, IHash, IIRParent, ToJson, IRHoistedMetadata {
+    readonly meta: IRHoistedMeta;
+    constructor(hoisted: IRTerm, metadata?: Partial<IRHoistedMeta>, _unsafeHash?: IRHash);
+    static get kind(): IRNodeKind.Hoisted;
+    get kind(): IRNodeKind.Hoisted;
+    static get tag(): Uint8Array;
+    private _hash;
+    get hash(): IRHash;
+    markHashAsInvalid(): void;
+    isHashPresent(): boolean;
+    private _hoisted;
+    get hoisted(): IRTerm;
+    set hoisted(newHoisted: IRTerm);
+    private _deps;
+    get dependencies(): HoistedSetEntry[];
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRParentTerm | undefined);
+    clone(): IRHoisted;
+    toJSON(): any;
+    toJson(): any;
+}
+/**
+ * basically an insertion sort;
+ *
+ * @param {HoistedSetEntry[]} hoistedTerms
+ * @returns {HoistedSetEntry[]} a **new** array with ```IRHoisted```s with no dependencies first, followed by the dependents
+ */
+export declare function getSortedHoistedSet(hoistedTerms: HoistedSetEntry[]): HoistedSetEntry[];
+export declare function getHoistedTerms(irTerm: IRTerm): HoistedSetEntry[];
+export declare function cloneHoistedSetEntry({ hoisted, nReferences }: HoistedSetEntry): HoistedSetEntry;

package/dist/IR/IRNodes/IRHoisted.js

@@ -0,0 +1,212 @@
+import { IRDelayed } from "./IRDelayed.js";
+import { freezeAll } from "@harmoniclabs/obj-utils";
+import { BasePlutsError } from "../../utils/BasePlutsError.js";
+import { concatUint8Arr } from "../utils/concatUint8Arr.js";
+import { isClosedIRTerm } from "../utils/isClosedIRTerm.js";
+import { IRApp } from "./IRApp.js";
+import { IRForced } from "./IRForced.js";
+import { IRFunc } from "./IRFunc.js";
+import { IRLetted } from "./IRLetted.js";
+import { isIRParentTerm } from "../utils/isIRParentTerm.js";
+import { IRConstr } from "./IRConstr.js";
+import { IRCase } from "./IRCase.js";
+import { equalIrHash, hashIrData, irHashToHex, isIRHash } from "../IRHash.js";
+import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+import { IRRecursive } from "./IRRecursive.js";
+const defaultHoistedMeta = freezeAll({
+    forceHoist: false
+});
+export class IRHoisted {
+    meta;
+    constructor(hoisted, metadata = {}, _unsafeHash) {
+        // unwrap
+        // !!! IMPORTANT !!!
+        while (hoisted instanceof IRHoisted)
+            hoisted = hoisted.hoisted;
+        if (!isClosedIRTerm(hoisted)) {
+            throw new BasePlutsError("only closed terms can be hoisted");
+        }
+        // initialize without calling "set"
+        this._hoisted = hoisted;
+        this._hoisted.parent = this;
+        this._deps = undefined;
+        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
+        this._parent = undefined;
+        this.meta = {
+            ...defaultHoistedMeta,
+            ...metadata,
+            name: this._hoisted.meta?.name ?? metadata.name
+        };
+    }
+    static get kind() { return IRNodeKind.Hoisted; }
+    get kind() { return IRHoisted.kind; }
+    static get tag() { return new Uint8Array([IRHoisted.kind]); }
+    _hash;
+    get hash() {
+        if (!isIRHash(this._hash)) {
+            this._hash = hashIrData(concatUint8Arr(IRHoisted.tag, this.hoisted.hash));
+        }
+        return this._hash;
+    }
+    markHashAsInvalid() {
+        this._hash = undefined;
+        this._deps = undefined;
+        this.parent?.markHashAsInvalid();
+    }
+    isHashPresent() {
+        return isIRHash(this._hash);
+    }
+    _hoisted;
+    get hoisted() { return this._hoisted; }
+    set hoisted(newHoisted) {
+        if (!isClosedIRTerm(newHoisted))
+            throw new BasePlutsError("only closed terms can be hoisted");
+        if (!shallowEqualIRTermHash(this._hoisted, newHoisted))
+            this.markHashAsInvalid();
+        // dependencies need to be updated EVEN if hash is the same
+        // since the terms might be the same but maybe cloned
+        this._deps = undefined;
+        // keep the parent reference in the old child, useful for compilation
+        // _hoisted.parent = undefined;
+        this._hoisted = newHoisted;
+        this._hoisted.parent = this;
+    }
+    _deps;
+    get dependencies() {
+        if (this._deps === undefined)
+            this._deps = getSortedHoistedSet(getHoistedTerms(this._hoisted));
+        return this._deps;
+    }
+    _parent;
+    get parent() { return this._parent; }
+    set parent(newParent) {
+        if (!( // assert
+        // new parent value is different than current
+        this._parent !== newParent && (
+        // and the new parent value is valid
+        newParent === undefined ||
+            isIRParentTerm(newParent))))
+            return;
+        this._parent = newParent;
+    }
+    clone() {
+        return new IRHoisted(this.hoisted.clone(), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
+    }
+    toJSON() { return this.toJson(); }
+    toJson() {
+        return {
+            type: "IRHoisted",
+            hash: irHashToHex(this.hash),
+            hoisted: this.hoisted.toJson()
+        };
+    }
+}
+/**
+ * basically an insertion sort;
+ *
+ * @param {HoistedSetEntry[]} hoistedTerms
+ * @returns {HoistedSetEntry[]} a **new** array with ```IRHoisted```s with no dependencies first, followed by the dependents
+ */
+export function getSortedHoistedSet(hoistedTerms) {
+    const set = [];
+    const hashesSet = [];
+    /**
+     * **O((n * m) * d)**
+     *
+     * where
+     *
+     *      n = length of set
+     *      m = number of terms passed
+     *      d = number of unique dependencies among the passed terms
+     */
+    function addToSet(..._terms) {
+        for (let i = 0; i < _terms.length; i++) {
+            const thisHoistedEntry = _terms[i];
+            const thisHash = thisHoistedEntry.hoisted.hash;
+            const idxInSet = hashesSet.findIndex(hash => equalIrHash(hash, thisHash));
+            // if( !hashesSet.includes( compiled ) )
+            // "includes" uses standard equality (===)
+            if (idxInSet < 0) // not present
+             {
+                // add dependencies first
+                addToSet(..._terms[i].hoisted.dependencies);
+                hashesSet.push(thisHash);
+                set.push(thisHoistedEntry);
+            }
+            else {
+                const entry = set[idxInSet];
+                entry.nReferences += thisHoistedEntry.nReferences;
+                entry.hoisted.meta.forceHoist =
+                    entry.hoisted.meta.forceHoist ||
+                        thisHoistedEntry.hoisted.meta.forceHoist;
+            }
+        }
+    }
+    addToSet(...hoistedTerms);
+    return set;
+}
+export function getHoistedTerms(irTerm) {
+    const hoisteds = [];
+    function searchIn(term) {
+        if (term instanceof IRHoisted) {
+            // only push direct hoisteds
+            // dependencies are counted calling `getSortedHoistedSet`
+            hoisteds.push({ hoisted: term, nReferences: 1 });
+            return;
+        }
+        if (term instanceof IRApp) {
+            searchIn(term.fn);
+            searchIn(term.arg);
+            return;
+        }
+        if (term instanceof IRConstr) {
+            for (let i = 0; i < term.fields.length; i++) {
+                searchIn(term.fields[i]);
+            }
+            return;
+        }
+        if (term instanceof IRCase) {
+            searchIn(term.constrTerm);
+            for (let i = 0; i < term.continuations.length; i++) {
+                searchIn(term.continuations[i]);
+            }
+            return;
+        }
+        if (term instanceof IRFunc) {
+            searchIn(term.body);
+            return;
+        }
+        if (term instanceof IRRecursive) {
+            searchIn(term.body);
+            return;
+        }
+        if (term instanceof IRLetted) {
+            // useless
+            // term.dependencies.forEach( searchIn )
+            // dependecies are still in the body anyway (hoisted are closed)
+            searchIn(term.value);
+            return;
+        }
+        if (term instanceof IRForced) {
+            searchIn(term.forced);
+            return;
+        }
+        if (term instanceof IRDelayed) {
+            searchIn(term.delayed);
+            return;
+        }
+        // if( term instanceof IRNative ) return;
+        // if( term instanceof IRVar ) return;
+        // if( term instanceof IRConst ) return;
+        // if( term instanceof IRError ) return;
+    }
+    searchIn(irTerm);
+    return hoisteds;
+}
+export function cloneHoistedSetEntry({ hoisted, nReferences }) {
+    return {
+        hoisted: hoisted.clone(),
+        nReferences
+    };
+}

package/dist/IR/IRNodes/IRLetted.d.ts

@@ -0,0 +1,108 @@
+import { IRMetadata } from "../interfaces/IRMetadata.js";
+import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
+import { ToJson } from "../../utils/ToJson.js";
+import { IRTerm } from "../IRTerm.js";
+import { IHash, IIRParent } from "../interfaces/index.js";
+import { IRParentTerm } from "../utils/isIRParentTerm.js";
+import { BaseIRMetadata } from "./BaseIRMetadata.js";
+import { IRHash } from "../IRHash.js";
+import { IRNodeKind } from "../IRNodeKind.js";
+export type LettedSetEntry = {
+    letted: IRLetted;
+    nReferences: number;
+};
+export declare function jsonLettedSetEntry(entry: LettedSetEntry): {
+    letted: string;
+    nReferences: number;
+};
+export declare function expandedJsonLettedSetEntry(entry: LettedSetEntry): {
+    letted: string;
+    nReferences: number;
+};
+export interface IRLettedMeta extends BaseIRMetadata {
+    /**
+     * force hoisting even if only a single reference is found
+     *
+     * useful to hoist letted terms used once in recursive expressions
+    **/
+    forceHoist: boolean;
+    __src__?: string | undefined;
+    isClosed: boolean;
+}
+export interface IRLettedMetadata extends IRMetadata {
+    meta: IRLettedMeta;
+}
+export declare class IRLetted implements Cloneable<IRLetted>, IHash, IIRParent, ToJson, IRLettedMetadata {
+    private _hash;
+    get hash(): IRHash;
+    markHashAsInvalid(): void;
+    isHashPresent(): boolean;
+    private _value;
+    get value(): IRTerm;
+    set value(newVal: IRTerm);
+    private _dbn;
+    /**
+     * we need to keep track of the debruijn at which the `IRLetted` is instantiated
+     *
+     * this is because stuff like `new IRLetted( new IRVar(0) )` has different meaning
+     * at different DeBruijn levels
+     *
+     * knowing the DeBruijn we can differentiate them
+     */
+    get dbn(): number;
+    set dbn(newDbn: number);
+    isClosedAtDbn(dbn: number): boolean;
+    private _deps;
+    get dependencies(): LettedSetEntry[];
+    private _parent;
+    get parent(): IRParentTerm | undefined;
+    set parent(newParent: IRParentTerm | undefined);
+    readonly meta: IRLettedMeta;
+    constructor(DeBruijn: number | bigint, toLet: IRTerm, metadata?: Partial<IRLettedMeta>, _unsafeHash?: IRHash | undefined);
+    static get kind(): IRNodeKind.Letted;
+    get kind(): IRNodeKind.Letted;
+    static get tag(): Uint8Array;
+    clone(): IRLetted;
+    toJSON(): any;
+    toJson(): any;
+}
+/**
+ * basically an insertion sort;
+ *
+ * @param {LettedSetEntry[]} lettedTerms
+ * @returns {LettedSetEntry[]} a **new** array with ```IRLetted```s with no dependencies first, followed by the dependents
+ */
+export declare function getSortedLettedSet(lettedTerms: LettedSetEntry[]): LettedSetEntry[];
+export interface GetLettedTermsOptions {
+    /**
+     * looks for letted terms inside other letted terms
+     *
+     * (unnecessary if called only to later pass the result to `getSortedLettedSet`)
+     */
+    all: boolean;
+    /**
+     * look for letted terms inside hoisted terms (always closed)
+     */
+    includeHoisted: boolean;
+}
+export declare const default_getLettedTermsOptions: GetLettedTermsOptions;
+/**
+ *
+ * @param {IRTerm} irTerm term to search in
+ * @returns direct letted terms (no possible dependencies)
+ */
+export declare function getLettedTerms(irTerm: IRTerm, options?: Partial<GetLettedTermsOptions>): LettedSetEntry[];
+export declare function getNormalizedLettedArgs(lettedDbn: number, value: IRTerm): [normalized_dbn: number, noramlized_value: IRTerm] | undefined;
+/**
+ *
+ * @param term the ir term to iter to search for vars
+ * @returns {number | undefined}
+ *
+ * @example
+ * ```ts
+ * let minDbn = getMinVarDbn( new IRVar(0) ); // 0
+ * minDbn = getMinVarDbn( IRConst.unit ); // undefined
+ * minDbn = getMinVarDbn( new IRFunc( 1, new IRVar( 0 ) ) ); // 0
+ * ```
+ */
+export declare function getMinVarDbn(term: IRTerm): number | undefined;