@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev3

package/dist/compiler/tir/types/TirNativeType/native/Optional/sop.js

@@ -0,0 +1,48 @@
+import { getAppliedTirTypeName } from "../../../../program/TypedProgram.js";
+import { TirSoPStructType, TirStructConstr, TirStructField } from "../../../TirStructType.js";
+export class TirSopOptT extends TirSoPStructType {
+    typeArg;
+    constructor(typeArg) {
+        super("Optional", // name
+        "", // fileUid
+        [
+            new TirStructConstr("Some", // name
+            [
+                new TirStructField("value", typeArg)
+            ]),
+            new TirStructConstr("None", []) // name, fields
+        ], new Map() // methodNamesPtr
+        );
+        this.typeArg = typeArg;
+    }
+    hasDataEncoding() { return false; }
+    toAstName() {
+        return "Optional";
+    }
+    toString() {
+        return `${this.toAstName()}<${this.typeArg.toString()}>`;
+    }
+    static toTirTypeKey() {
+        return "sop_opt";
+    }
+    toTirTypeKey() {
+        return TirSopOptT.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.typeArg.isConcrete();
+        return this._isConcrete;
+    }
+    clone() {
+        const result = new TirSopOptT(this.typeArg.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        throw new Error("SoP encoded optional cannot be represented as uplc const");
+    }
+}

package/dist/compiler/tir/types/TirNativeType/native/bool.d.ts

@@ -0,0 +1,13 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import type { ITirType } from "../../TirType.js";
+export declare class TirBoolT implements ITirType {
+    clone(): TirBoolT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/bool.js

@@ -0,0 +1,12 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirBoolT {
+    clone() { return new TirBoolT(); }
+    isConcrete() { return true; }
+    toString() { return "boolean"; }
+    toAstName() { return "boolean"; }
+    static toTirTypeKey() { return "boolean"; }
+    toTirTypeKey() { return TirBoolT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.bool; }
+}

package/dist/compiler/tir/types/TirNativeType/native/bytes.d.ts

@@ -0,0 +1,13 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType } from "../../TirType.js";
+export declare class TirBytesT implements ITirType {
+    clone(): TirBytesT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/bytes.js

@@ -0,0 +1,12 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirBytesT {
+    clone() { return new TirBytesT(); }
+    isConcrete() { return true; }
+    toString() { return "bytes"; }
+    toAstName() { return "bytes"; }
+    static toTirTypeKey() { return "bytes"; }
+    toTirTypeKey() { return TirBytesT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.byteStr; }
+}

package/dist/compiler/tir/types/TirNativeType/native/data.d.ts

@@ -0,0 +1,13 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType } from "../../TirType.js";
+export declare class TirDataT implements ITirType {
+    clone(): TirDataT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/data.js

@@ -0,0 +1,12 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirDataT {
+    clone() { return new TirDataT(); }
+    isConcrete() { return true; }
+    toString() { return "data"; }
+    toAstName() { return "data"; }
+    static toTirTypeKey() { return "data"; }
+    toTirTypeKey() { return TirDataT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.data; }
+}

package/dist/compiler/tir/types/TirNativeType/native/function.d.ts

@@ -0,0 +1,16 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType, TirType } from "../../TirType.js";
+export declare class TirFuncT implements ITirType {
+    readonly argTypes: TirType[];
+    readonly returnType: TirType;
+    constructor(argTypes: TirType[], returnType: TirType);
+    hasDataEncoding(): boolean;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toAstName(): string;
+    toString(): string;
+    private _isConcrete;
+    isConcrete(): boolean;
+    clone(): TirFuncT;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/function.js

@@ -0,0 +1,38 @@
+export class TirFuncT {
+    argTypes;
+    returnType;
+    constructor(
+    // readonly genericTyArgsName: TirTypeParam[],
+    argTypes, returnType) {
+        this.argTypes = argTypes;
+        this.returnType = returnType;
+    }
+    hasDataEncoding() { return false; }
+    toTirTypeKey() {
+        return "func_" + this.argTypes.map(t => t.toConcreteTirTypeName()).join("_") + "_" + this.returnType.toConcreteTirTypeName();
+    }
+    toConcreteTirTypeName() {
+        return this.toTirTypeKey();
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    toString() {
+        return `(${this.argTypes.map(t => t.toString()).join(",")}) => ${this.returnType.toString()}`;
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = (this.argTypes.every(t => t.isConcrete())
+                && this.returnType.isConcrete());
+        return this._isConcrete ?? false;
+    }
+    clone() {
+        const result = new TirFuncT(this.argTypes.map(t => t.clone()), this.returnType.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        throw new Error("TirFuncT cannot be represented as uplc const type");
+    }
+}

package/dist/compiler/tir/types/TirNativeType/native/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./Optional/index.js";
+export * from "./bool.js";
+export * from "./bytes.js";
+export * from "./data.js";
+export * from "./function.js";
+export * from "./int.js";
+export * from "./linearMap.js";
+export * from "./list.js";
+export * from "./string.js";
+export * from "./void.js";

package/dist/compiler/tir/types/TirNativeType/native/index.js

@@ -0,0 +1,10 @@
+export * from "./Optional/index.js";
+export * from "./bool.js";
+export * from "./bytes.js";
+export * from "./data.js";
+export * from "./function.js";
+export * from "./int.js";
+export * from "./linearMap.js";
+export * from "./list.js";
+export * from "./string.js";
+export * from "./void.js";

package/dist/compiler/tir/types/TirNativeType/native/int.d.ts

@@ -0,0 +1,13 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType } from "../../TirType.js";
+export declare class TirIntT implements ITirType {
+    clone(): TirIntT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/int.js

@@ -0,0 +1,12 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirIntT {
+    clone() { return new TirIntT(); }
+    isConcrete() { return true; }
+    toString() { return "int"; }
+    toAstName() { return "int"; }
+    static toTirTypeKey() { return "int"; }
+    toTirTypeKey() { return TirIntT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.int; }
+}

package/dist/compiler/tir/types/TirNativeType/native/linearMap.d.ts

@@ -0,0 +1,17 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirType, ITirType } from "../../TirType.js";
+export declare class TirLinearMapT<K extends TirType = TirType, V extends TirType = TirType> implements ITirType {
+    readonly keyTypeArg: K;
+    readonly valTypeArg: V;
+    constructor(keyTypeArg: K, valTypeArg: V);
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toAstName(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    private _isConcrete;
+    isConcrete(): boolean;
+    clone(): TirLinearMapT<K, V>;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/linearMap.js

@@ -0,0 +1,44 @@
+import { constT } from "@harmoniclabs/uplc";
+import { getAppliedTirTypeName } from "../../../program/TypedProgram.js";
+export class TirLinearMapT {
+    keyTypeArg;
+    valTypeArg;
+    constructor(keyTypeArg, valTypeArg) {
+        this.keyTypeArg = keyTypeArg;
+        this.valTypeArg = valTypeArg;
+    }
+    hasDataEncoding() { return this.keyTypeArg.hasDataEncoding() && this.valTypeArg.hasDataEncoding(); }
+    static toTirTypeKey() {
+        return "list_pair_data";
+    }
+    toTirTypeKey() {
+        return TirLinearMapT.toTirTypeKey();
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return getAppliedTirTypeName(this.toTirTypeKey(), [
+            this.keyTypeArg.toConcreteTirTypeName(),
+            this.valTypeArg.toConcreteTirTypeName()
+        ]);
+    }
+    toString() {
+        return `${this.toTirTypeKey()}<${this.keyTypeArg.toString()},${this.valTypeArg.toString()}>`;
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = (this.keyTypeArg.isConcrete()
+                && this.valTypeArg.isConcrete());
+        return this._isConcrete ?? false;
+    }
+    clone() {
+        const result = new TirLinearMapT(this.keyTypeArg.clone(), this.valTypeArg.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        return constT.listOf(constT.pairOf(constT.data, constT.data));
+    }
+}

package/dist/compiler/tir/types/TirNativeType/native/list.d.ts

@@ -0,0 +1,16 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { TirType, ITirType } from "../../TirType.js";
+export declare class TirListT<T extends TirType = TirType> implements ITirType {
+    readonly typeArg: T;
+    constructor(typeArg: T);
+    hasDataEncoding(): boolean;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    toString(): string;
+    toAstName(): string;
+    private _isConcrete;
+    isConcrete(): boolean;
+    clone(): TirListT<T>;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/list.js

@@ -0,0 +1,38 @@
+import { constT } from "@harmoniclabs/uplc";
+import { getAppliedTirTypeName } from "../../../program/TypedProgram.js";
+export class TirListT {
+    typeArg;
+    constructor(typeArg) {
+        this.typeArg = typeArg;
+    }
+    hasDataEncoding() { return this.typeArg.hasDataEncoding(); }
+    static toTirTypeKey() {
+        return "List";
+    }
+    toTirTypeKey() {
+        return TirListT.toTirTypeKey();
+    }
+    toConcreteTirTypeName() {
+        return getAppliedTirTypeName(this.toTirTypeKey(), [this.typeArg.toConcreteTirTypeName()]);
+    }
+    toString() {
+        return `${this.toTirTypeKey()}<${this.typeArg.toString()}>`;
+    }
+    toAstName() {
+        return this.toTirTypeKey();
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.typeArg.isConcrete();
+        return this._isConcrete ?? false;
+    }
+    clone() {
+        const result = new TirListT(this.typeArg.clone());
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        return constT.listOf(this.typeArg.toUplcConstType());
+    }
+}

package/dist/compiler/tir/types/TirNativeType/native/string.d.ts

@@ -0,0 +1,13 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType } from "../../TirType.js";
+export declare class TirStringT implements ITirType {
+    clone(): TirStringT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/string.js

@@ -0,0 +1,12 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirStringT {
+    clone() { return new TirStringT(); }
+    isConcrete() { return true; }
+    toString() { return "string"; }
+    toAstName() { return "string"; }
+    static toTirTypeKey() { return "string"; }
+    toTirTypeKey() { return TirStringT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.str; }
+}

package/dist/compiler/tir/types/TirNativeType/native/void.d.ts

@@ -0,0 +1,13 @@
+import { ConstType } from "@harmoniclabs/uplc";
+import { ITirType } from "../../TirType.js";
+export declare class TirVoidT implements ITirType {
+    clone(): TirVoidT;
+    isConcrete(): boolean;
+    toString(): string;
+    toAstName(): string;
+    static toTirTypeKey(): string;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    hasDataEncoding(): boolean;
+    toUplcConstType(): ConstType;
+}

package/dist/compiler/tir/types/TirNativeType/native/void.js

@@ -0,0 +1,12 @@
+import { constT } from "@harmoniclabs/uplc";
+export class TirVoidT {
+    clone() { return new TirVoidT(); }
+    isConcrete() { return true; }
+    toString() { return "void"; }
+    toAstName() { return "void"; }
+    static toTirTypeKey() { return "void"; }
+    toTirTypeKey() { return TirVoidT.toTirTypeKey(); }
+    toConcreteTirTypeName() { return this.toTirTypeKey(); }
+    hasDataEncoding() { return true; }
+    toUplcConstType() { return constT.unit; }
+}

package/dist/compiler/tir/types/TirStructType.d.ts

@@ -0,0 +1,68 @@
+import { ITirType, TirType } from "./TirType.js";
+import { AstFuncName, TirFuncName } from "../../AstCompiler/scope/AstScope.js";
+import { ConstType } from "@harmoniclabs/uplc";
+export interface ITirStructType extends ITirType {
+    readonly name: string;
+    readonly fileUid: string;
+    readonly constructors: TirStructConstr[];
+    /** points to an array possibly shared with alternative encoding types */
+    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
+}
+export type TirStructType = TirDataStructType | TirSoPStructType;
+export declare function isTirStructType(thing: any): thing is TirStructType;
+export declare class TirDataStructType implements ITirStructType {
+    readonly name: string;
+    readonly fileUid: string;
+    readonly constructors: TirStructConstr[];
+    /** points to an array possibly shared with alternative encoding types */
+    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
+    readonly untagged: boolean;
+    constructor(name: string, fileUid: string, constructors: TirStructConstr[], 
+    /** points to an array possibly shared with alternative encoding types */
+    methodNamesPtr: Map<AstFuncName, TirFuncName>, untagged?: boolean);
+    hasDataEncoding(): boolean;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    isSingleConstr(): boolean;
+    toString(): string;
+    toAstName(): string;
+    protected _isConcrete: boolean | undefined;
+    isConcrete(): boolean;
+    clone(): TirDataStructType;
+    toUplcConstType(): ConstType;
+}
+export declare class TirSoPStructType implements ITirStructType {
+    readonly name: string;
+    readonly fileUid: string;
+    readonly constructors: TirStructConstr[];
+    /** points to an array possibly shared with alternative encoding types */
+    readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
+    constructor(name: string, fileUid: string, constructors: TirStructConstr[], 
+    /** points to an array possibly shared with alternative encoding types */
+    methodNamesPtr: Map<AstFuncName, TirFuncName>);
+    hasDataEncoding(): boolean;
+    toTirTypeKey(): string;
+    toConcreteTirTypeName(): string;
+    isSingleConstr(): boolean;
+    toString(): string;
+    toAstName(): string;
+    protected _isConcrete: boolean | undefined;
+    isConcrete(): boolean;
+    clone(): TirSoPStructType;
+    toUplcConstType(): ConstType;
+}
+export declare class TirStructConstr {
+    readonly name: string;
+    readonly fields: TirStructField[];
+    constructor(name: string, fields: TirStructField[]);
+    toString(): string;
+    isConcrete(): boolean;
+    clone(): TirStructConstr;
+}
+export declare class TirStructField {
+    readonly name: string;
+    readonly type: TirType;
+    constructor(name: string, type: TirType);
+    isConcrete(): boolean;
+    clone(): TirStructField;
+}

package/dist/compiler/tir/types/TirStructType.js

@@ -0,0 +1,128 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { constT } from "@harmoniclabs/uplc";
+export function isTirStructType(thing) {
+    return isObject(thing) && (thing instanceof TirDataStructType
+        || thing instanceof TirSoPStructType);
+}
+export class TirDataStructType {
+    name;
+    fileUid;
+    constructors;
+    methodNamesPtr;
+    untagged;
+    constructor(name, fileUid, constructors, 
+    /** points to an array possibly shared with alternative encoding types */
+    methodNamesPtr, untagged = false) {
+        this.name = name;
+        this.fileUid = fileUid;
+        this.constructors = constructors;
+        this.methodNamesPtr = methodNamesPtr;
+        this.untagged = untagged;
+        this.untagged = false; // always false for now
+    }
+    hasDataEncoding() { return true; }
+    toTirTypeKey() {
+        return "data_" + this.name + "_" + this.fileUid;
+    }
+    toConcreteTirTypeName() {
+        return this.toTirTypeKey();
+    }
+    isSingleConstr() {
+        return this.constructors.length === 1;
+    }
+    toString() {
+        return this.name;
+    }
+    toAstName() {
+        return this.toString();
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.constructors.every(c => c.isConcrete());
+        return this._isConcrete;
+    }
+    clone() {
+        const result = new TirDataStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr);
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        return constT.data;
+    }
+}
+export class TirSoPStructType {
+    name;
+    fileUid;
+    constructors;
+    methodNamesPtr;
+    constructor(name, fileUid, constructors, 
+    /** points to an array possibly shared with alternative encoding types */
+    methodNamesPtr) {
+        this.name = name;
+        this.fileUid = fileUid;
+        this.constructors = constructors;
+        this.methodNamesPtr = methodNamesPtr;
+    }
+    hasDataEncoding() { return false; }
+    toTirTypeKey() {
+        return "sop_" + this.name + "_" + this.fileUid;
+    }
+    toConcreteTirTypeName() {
+        return this.toTirTypeKey();
+    }
+    isSingleConstr() {
+        return this.constructors.length === 1;
+    }
+    toString() {
+        return this.name;
+    }
+    toAstName() {
+        return this.toString();
+    }
+    _isConcrete = undefined;
+    isConcrete() {
+        if (typeof this._isConcrete !== "boolean")
+            this._isConcrete = this.constructors.every(c => c.isConcrete());
+        return this._isConcrete;
+    }
+    clone() {
+        const result = new TirSoPStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr);
+        result._isConcrete = this._isConcrete;
+        return result;
+    }
+    toUplcConstType() {
+        throw new Error("SoP struct cannot be represented as uplc constants.");
+    }
+}
+export class TirStructConstr {
+    name;
+    fields;
+    constructor(name, fields) {
+        this.name = name;
+        this.fields = fields;
+    }
+    toString() {
+        return this.name;
+    }
+    isConcrete() {
+        return this.fields.every(f => f.isConcrete());
+    }
+    clone() {
+        return new TirStructConstr(this.name, this.fields.map(f => f.clone()));
+    }
+}
+export class TirStructField {
+    name;
+    type;
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+    isConcrete() {
+        return this.type.isConcrete();
+    }
+    clone() {
+        return new TirStructField(this.name, this.type.clone());
+    }
+}

package/dist/compiler/tir/types/TirType.d.ts

@@ -0,0 +1,34 @@
+import { TirAliasType } from "./TirAliasType.js";
+import { TirStructType } from "./TirStructType.js";
+import { TirNamedDestructableNativeType, TirNativeType } from "./TirNativeType/TirNativeType.js";
+import { TirTypeParam } from "./TirTypeParam.js";
+import { ConstType } from "@harmoniclabs/uplc";
+export interface ITirType {
+    /** @returns the AST name (human friendly) */
+    toString(): string;
+    /**
+     * @returns the TIR name
+     *
+     * if the type is generic, it returns only the name of the generic type
+     **/
+    toTirTypeKey(): string;
+    /**
+     * @returns the (unapplied) AST name
+     *
+     * if the type is generic, it return only the name of the generic type
+     * and not the type parameters
+     *
+     * if the type is concrete, it returns the same as `toString()`
+     */
+    toAstName(): string;
+    /**
+     * translate to uplc type
+     */
+    toUplcConstType(): ConstType;
+}
+export type TirType = TirNativeType | TirCustomType | TirTypeParam;
+export declare function isTirType(thing: any): thing is TirType;
+export type TirCustomType = TirAliasType | TirStructType;
+export declare function isTirCustomType(thing: any): thing is TirCustomType;
+export type TirNamedDestructableType = TirNamedDestructableNativeType | TirStructType;
+export declare function isTirNamedDestructableType(thing: any): thing is TirNamedDestructableType;

package/dist/compiler/tir/types/TirType.js

@@ -0,0 +1,16 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { TirAliasType } from "./TirAliasType.js";
+import { isTirStructType } from "./TirStructType.js";
+import { isTirNamedDestructableNativeType, isTirNativeType } from "./TirNativeType/TirNativeType.js";
+export function isTirType(thing) {
+    return isObject(thing) && (isTirNativeType(thing)
+        || isTirCustomType(thing));
+}
+export function isTirCustomType(thing) {
+    return isObject(thing) && (thing instanceof TirAliasType
+        || isTirStructType(thing));
+}
+export function isTirNamedDestructableType(thing) {
+    return isObject(thing) && (isTirStructType(thing)
+        || isTirNamedDestructableNativeType(thing));
+}