@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,33 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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;