@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmoniclabs/pebble",
-  "version": "0.1.0-dev1",
+  "version": "0.1.0-dev2",
   "description": "A simple, yet rock solid, functional language with an imperative bias, targeting UPLC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/IR/IRHash.d.ts

@@ -1,8 +0,0 @@
-export type IRHash = Readonly<Uint32Array> & {
-    length: 4;
-};
-export declare function hashIrData(data: Uint8Array): IRHash;
-export declare function isIRHash(hash: any): hash is IRHash;
-export declare function equalIrHash(a: IRHash, b: IRHash): boolean;
-export declare function irHashToHex(hash: IRHash): string;
-export declare function irHashFromHex(hex: string): IRHash;

package/dist/IR/IRHash.js

@@ -1,78 +0,0 @@
-import { blake2b_128 } from "@harmoniclabs/crypto";
-import { toHex } from "@harmoniclabs/uint8array-utils";
-const _hash_cache = new Map();
-// double up to 256; then scale linearly
-const _MAX_DOUBLING_CACHE_SIZE = 256;
-const _MIN_CACHE_SIZE = 32;
-let _cleanSize = _MIN_CACHE_SIZE;
-function _cleanCache() {
-    // scale down
-    if (_hash_cache.size < _cleanSize) {
-        if (_cleanSize <= _MIN_CACHE_SIZE)
-            return; // don't clean unitl minimum size
-        const halfSize = _cleanSize >= (_MAX_DOUBLING_CACHE_SIZE * 2) ? _cleanSize - _MAX_DOUBLING_CACHE_SIZE : _cleanSize >>> 1;
-        if (_hash_cache.size < halfSize)
-            _cleanSize = halfSize;
-    }
-    // cleaning
-    for (const [key, ref] of _hash_cache.entries()) {
-        if (ref.deref() === undefined)
-            _hash_cache.delete(key);
-    }
-    // scale up
-    if (_hash_cache.size >= _cleanSize) {
-        _cleanSize = _cleanSize >= _MAX_DOUBLING_CACHE_SIZE ?
-            _cleanSize + _MAX_DOUBLING_CACHE_SIZE :
-            _cleanSize * 2;
-    }
-}
-export function hashIrData(data) {
-    const hash8 = blake2b_128(data);
-    const key = toHex(hash8);
-    const cached = _hash_cache.get(key)?.deref();
-    if (isIRHash(cached))
-        return cached;
-    const result = new Uint32Array(hash8.buffer);
-    _hash_cache.set(key, new WeakRef(result));
-    _cleanCache();
-    return result;
-}
-export function isIRHash(hash) {
-    return (
-    // most of the time we are checking an undefined value
-    // we just shortcut here
-    hash !== undefined &&
-        hash instanceof Uint32Array &&
-        hash.length === 4);
-}
-export function equalIrHash(a, b) {
-    // we can allow ourselves to use standard equality
-    // only because we always return the same object for the same hash
-    return a === b;
-    /*
-    return (
-        // a instanceof Uint32Array &&
-        // b instanceof Uint32Array &&
-        // a.length === 4 &&
-        // b.length === 4 &&
-        a[0] === b[0] &&
-        a[1] === b[1] &&
-        a[2] === b[2] &&
-        a[3] === b[3]
-    );
-    //*/
-}
-export function irHashToHex(hash) {
-    return toHex(new Uint8Array(hash.buffer));
-}
-export function irHashFromHex(hex) {
-    if (hex.length !== 32 && !/^[0-9a-fA-F]$/.test(hex)) {
-        throw new Error("invalid hex string for IRHash");
-    }
-    return new Uint32Array([
-        parseInt(hex.slice(0, 8), 16),
-        parseInt(hex.slice(8, 16), 16),
-        parseInt(hex.slice(16, 24), 16),
-        parseInt(hex.slice(24, 32), 16)
-    ]);
-}

package/dist/IR/IRNodeKind.d.ts

@@ -1,17 +0,0 @@
-export declare enum IRNodeKind {
-    Var = 0,
-    Func = 1,
-    App = 2,
-    Const = 3,
-    Native = 4,
-    Letted = 5,
-    Hoisted = 6,
-    Error = 7,
-    Forced = 8,
-    Delayed = 9,
-    Constr = 10,
-    Case = 11,
-    Recursive = 12,
-    SelfCall = 13,
-    SopDeconstr = 14
-}

package/dist/IR/IRNodeKind.js

@@ -1,19 +0,0 @@
-export var IRNodeKind;
-(function (IRNodeKind) {
-    IRNodeKind[IRNodeKind["Var"] = 0] = "Var";
-    IRNodeKind[IRNodeKind["Func"] = 1] = "Func";
-    IRNodeKind[IRNodeKind["App"] = 2] = "App";
-    IRNodeKind[IRNodeKind["Const"] = 3] = "Const";
-    IRNodeKind[IRNodeKind["Native"] = 4] = "Native";
-    IRNodeKind[IRNodeKind["Letted"] = 5] = "Letted";
-    IRNodeKind[IRNodeKind["Hoisted"] = 6] = "Hoisted";
-    IRNodeKind[IRNodeKind["Error"] = 7] = "Error";
-    IRNodeKind[IRNodeKind["Forced"] = 8] = "Forced";
-    IRNodeKind[IRNodeKind["Delayed"] = 9] = "Delayed";
-    IRNodeKind[IRNodeKind["Constr"] = 10] = "Constr";
-    IRNodeKind[IRNodeKind["Case"] = 11] = "Case";
-    IRNodeKind[IRNodeKind["Recursive"] = 12] = "Recursive";
-    IRNodeKind[IRNodeKind["SelfCall"] = 13] = "SelfCall";
-    IRNodeKind[IRNodeKind["SopDeconstr"] = 14] = "SopDeconstr";
-})(IRNodeKind || (IRNodeKind = {}));
-Object.freeze(IRNodeKind);

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

@@ -1,3 +0,0 @@
-export interface BaseIRMetadata {
-    name?: string | undefined;
-}

package/dist/IR/IRNodes/BaseIRMetadata.js

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

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

@@ -1,36 +0,0 @@
-import { IRTerm } from "../IRTerm.js";
-import { IHash } from "../interfaces/IHash.js";
-import { IIRParent } from "../interfaces/IIRParent.js";
-import { ToJson } from "../../utils/ToJson.js";
-import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
-import { IRParentTerm } from "../utils/isIRParentTerm.js";
-import { BaseIRMetadata } from "./BaseIRMetadata.js";
-import { IRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export interface IRAppMeta extends BaseIRMetadata {
-    __src__?: string | undefined;
-}
-export declare class IRApp implements Cloneable<IRApp>, IHash, IIRParent, ToJson {
-    constructor(_fn_: IRTerm, _arg_: IRTerm, meta?: IRAppMeta | undefined, _unsafeHash?: IRHash);
-    static get kind(): IRNodeKind;
-    get kind(): IRNodeKind;
-    static get tag(): Uint8Array;
-    private _fn;
-    get fn(): IRTerm;
-    set fn(newFn: IRTerm);
-    private _arg;
-    get arg(): IRTerm;
-    set arg(newArg: IRTerm);
-    private _hash;
-    get hash(): IRHash;
-    markHashAsInvalid(): void;
-    isHashPresent(): boolean;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    private _meta;
-    get meta(): IRAppMeta;
-    clone(): IRApp;
-    toJSON(): any;
-    toJson(): any;
-}

package/dist/IR/IRNodes/IRApp.js

@@ -1,91 +0,0 @@
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { isIRTerm } from "../utils/isIRTerm.js";
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { isObject } from "@harmoniclabs/obj-utils";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export class IRApp {
-    constructor(_fn_, _arg_, meta = undefined, _unsafeHash) {
-        if (!isIRTerm(_fn_))
-            throw new Error("invalid function node for `IRApp`");
-        if (!isIRTerm(_arg_))
-            throw new Error("invalid argument node for `IRApp`");
-        this._meta = meta;
-        this._fn = _fn_;
-        this._arg = _arg_;
-        this._fn.parent = this;
-        this._arg.parent = this;
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-    }
-    static get kind() { return IRNodeKind.App; }
-    get kind() { return IRApp.kind; }
-    static get tag() { return new Uint8Array([IRApp.kind]); }
-    _fn;
-    get fn() { return this._fn; }
-    set fn(newFn) {
-        if (!isIRTerm(newFn))
-            return;
-        if (!shallowEqualIRTermHash(this._fn, newFn))
-            this.markHashAsInvalid();
-        // keep the parent reference in the old child, useful for compilation
-        // fn.parent = undefined;
-        this._fn = newFn;
-        this._fn.parent = this;
-    }
-    _arg;
-    get arg() { return this._arg; }
-    set arg(newArg) {
-        if (!isIRTerm(newArg))
-            return;
-        if (!shallowEqualIRTermHash(this._arg, newArg))
-            this.markHashAsInvalid();
-        // keep the parent reference in the old child, useful for compilation
-        // arg.parent = undefined;
-        this._arg = newArg;
-        this._arg.parent = this;
-    }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            // basically a merkle tree
-            this._hash = hashIrData(concatUint8Arr(IRApp.tag, this._fn.hash, this._arg.hash));
-        }
-        return this._hash;
-    }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    _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;
-        // change parent
-        this._parent = newParent;
-    }
-    _meta;
-    get meta() {
-        if (!isObject(this._meta))
-            this._meta = {};
-        return this._meta;
-    }
-    clone() {
-        return new IRApp(this.fn.clone(), this.arg.clone(), isObject(this._meta) ? { ...this._meta } : undefined, this.isHashPresent() ? this.hash : undefined);
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            type: "IRApp",
-            fn: this.fn.toJson(),
-            arg: this.arg.toJson()
-        };
-    }
-}

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

@@ -1,32 +0,0 @@
-import { Cloneable } from "../../utils/Cloneable.js";
-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 { MutArrayLike } from "../utils/MutArrayLike.js";
-import { IRHash } from "../IRHash.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-export interface IRCaseMeta extends BaseIRMetadata {
-}
-export declare class IRCase implements Cloneable<IRCase>, IHash, IIRParent, ToJson {
-    static get kind(): IRNodeKind.Case;
-    get kind(): IRNodeKind.Case;
-    static get tag(): Uint8Array;
-    constructor(constrTerm: IRTerm, continuations: ArrayLike<IRTerm>, meta?: IRCaseMeta, _unsafeHash?: IRHash);
-    private _hash;
-    get hash(): IRHash;
-    markHashAsInvalid(): void;
-    isHashPresent(): boolean;
-    private _constrTerm;
-    get constrTerm(): IRTerm;
-    set constrTerm(newConstrTerm: IRTerm);
-    readonly continuations: MutArrayLike<IRTerm>;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    readonly meta: IRCaseMeta;
-    clone(): IRCase;
-    toJSON(): any;
-    toJson(): any;
-}

package/dist/IR/IRNodes/IRCase.js

@@ -1,91 +0,0 @@
-import { concatUint8Arr } from "../utils/concatUint8Arr.js";
-import { isIRParentTerm } from "../utils/isIRParentTerm.js";
-import { mapArrayLike } from "./utils/mapArrayLike.js";
-import { makeArrayLikeProxy } from "./utils/makeArrayLikeProxy.js";
-import { hashIrData, isIRHash } from "../IRHash.js";
-import { shallowEqualIRTermHash } from "../utils/equalIRTerm.js";
-import { IRNodeKind } from "../IRNodeKind.js";
-import { isIRTerm } from "../utils/isIRTerm.js";
-export class IRCase {
-    static get kind() { return IRNodeKind.Case; }
-    get kind() { return IRCase.kind; }
-    static get tag() { return new Uint8Array([IRCase.kind]); }
-    constructor(constrTerm, continuations, meta = {}, _unsafeHash) {
-        const self = this;
-        this.meta = meta;
-        this._constrTerm = constrTerm;
-        this._constrTerm.parent = self;
-        Object.defineProperty(this, "continuations", {
-            value: makeArrayLikeProxy(continuations, isIRTerm, 
-            // initModifyElem
-            // function called once for each element in the array
-            // only at element definition
-            newElem => {
-                newElem.parent = self;
-                return newElem;
-            }, 
-            // modifyElem
-            (newElem, oldElem) => {
-                // keep the parent reference in the old child, useful for compilation
-                // oldElem.parent = undefined;
-                newElem.parent = self;
-                if (!shallowEqualIRTermHash(oldElem, newElem))
-                    self.markHashAsInvalid();
-                return newElem;
-            }),
-            writable: false,
-            enumerable: true,
-            configurable: false
-        });
-        this._hash = isIRHash(_unsafeHash) ? _unsafeHash : undefined;
-    }
-    _hash;
-    get hash() {
-        if (!isIRHash(this._hash)) {
-            // basically a merkle tree
-            this._hash = hashIrData(concatUint8Arr(IRCase.tag, this._constrTerm.hash, ...mapArrayLike(this.continuations, f => f.hash)));
-        }
-        return this._hash;
-    }
-    markHashAsInvalid() {
-        this._hash = undefined;
-        this.parent?.markHashAsInvalid();
-    }
-    isHashPresent() { return isIRHash(this._hash); }
-    _constrTerm;
-    get constrTerm() { return this._constrTerm; }
-    set constrTerm(newConstrTerm) {
-        if (!isIRTerm(newConstrTerm))
-            return;
-        if (!shallowEqualIRTermHash(this._constrTerm, newConstrTerm))
-            this.markHashAsInvalid();
-        // keep the parent reference in the old child, useful for compilation
-        // constrTerm.parent = undefined;
-        this._constrTerm = newConstrTerm;
-        this._constrTerm.parent = this;
-    }
-    continuations;
-    _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;
-    }
-    meta;
-    clone() {
-        return new IRCase(this.constrTerm, mapArrayLike(this.continuations, f => f.clone()), { ...this.meta }, this.isHashPresent() ? this.hash : undefined);
-    }
-    toJSON() { return this.toJson(); }
-    toJson() {
-        return {
-            constrTerm: this.constrTerm.toString(),
-            continuations: mapArrayLike(this.continuations, f => f.toJson())
-        };
-    }
-}

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

@@ -1,49 +0,0 @@
-import { Cloneable } from "@harmoniclabs/cbor/dist/utils/Cloneable";
-import { Data } from "@harmoniclabs/plutus-data";
-import { ToJson } from "../../utils/ToJson.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";
-import { TirType } from "../../compiler/tir/types/TirType.js";
-import { ConstType, UPLCConst } from "@harmoniclabs/uplc";
-export interface IRConstPair {
-    fst: IRConstValue;
-    snd: IRConstValue;
-}
-export declare function isIRConstPair(value: any): value is IRConstPair;
-export type IRConstValue = bigint | Uint8Array | string | boolean | IRConstValue[] | IRConstPair | Data | undefined;
-export interface IRConstMetadata extends BaseIRMetadata {
-}
-export declare class IRConst implements Cloneable<IRConst>, IHash, IIRParent, ToJson {
-    readonly type: TirType;
-    readonly value: IRConstValue;
-    static get kind(): IRNodeKind.Const;
-    get kind(): IRNodeKind.Const;
-    static get tag(): Uint8Array;
-    constructor(type: TirType, value: IRConstValue, _unsafeHash?: IRHash);
-    toUPLC(): UPLCConst;
-    private _hash;
-    get hash(): IRHash;
-    markHashAsInvalid(): void;
-    isHashPresent(): boolean;
-    private _meta;
-    get meta(): IRConstMetadata | undefined;
-    private _parent;
-    get parent(): IRParentTerm | undefined;
-    set parent(newParent: IRParentTerm | undefined);
-    clone(): IRConst;
-    toJSON(): any;
-    toJson(): any;
-    static get unit(): IRConst;
-    static bool(b: boolean): IRConst;
-    static bytes(b: Uint8Array): IRConst;
-    static int(n: number | bigint): IRConst;
-    static str(string: string): IRConst;
-    static data(d: Data): IRConst;
-    static listOf(t: TirType): (vals: IRConstValue[]) => IRConst;
-}
-export declare function isIRConstValue(value: any): value is IRConstValue;
-export declare function constValueToJson(value: IRConstValue): any;
-export declare function tirTypeToUplcType(t: TirType): ConstType;