@harmoniclabs/pebble 0.1.0-dev1 → 0.1.0-dev2

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

@@ -1,18 +0,0 @@
-import { ConstType } from "@harmoniclabs/uplc";
-import { ITirType } from "./TirType.js";
-export declare class TirTypeParam implements ITirType {
-    readonly name: string;
-    readonly symbol: symbol;
-    constructor(name: string, symbol?: symbol);
-    hasDataEncoding(): boolean;
-    toTirTypeKey(): string;
-    toConcreteTirTypeName(): string;
-    toString(): string;
-    toAstName(): string;
-    toInternalName(): string;
-    isConcrete(): boolean;
-    clone(): TirTypeParam;
-    eq(other: TirTypeParam): boolean;
-    static eq(a: TirTypeParam, b: TirTypeParam): boolean;
-    toUplcConstType(): ConstType;
-}

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

@@ -1,39 +0,0 @@
-export class TirTypeParam {
-    name;
-    symbol;
-    constructor(name, symbol) {
-        this.name = name;
-        this.name = name;
-        if (typeof symbol !== "symbol")
-            this.symbol = Symbol(name);
-    }
-    hasDataEncoding() { return false; }
-    toTirTypeKey() {
-        throw new Error("`toTirTypeKey` called on TirTypeParam; tir cannot have ambiguous types");
-    }
-    toConcreteTirTypeName() {
-        throw new Error("`toConcreteTirTypeName` called on TirTypeParam; tir cannot have ambiguous types");
-    }
-    toString() {
-        return this.name;
-    }
-    toAstName() {
-        return this.toString();
-    }
-    toInternalName() {
-        return this.toString();
-    }
-    isConcrete() { return false; }
-    clone() {
-        return new TirTypeParam(this.name, this.symbol);
-    }
-    eq(other) {
-        return this.symbol === other.symbol;
-    }
-    static eq(a, b) {
-        return a.symbol === b.symbol;
-    }
-    toUplcConstType() {
-        throw new Error("type parameters cannot be represented as uplc constants.");
-    }
-}

package/dist/compiler/tir/types/utils/canAssignTo.d.ts

@@ -1,24 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
-import { TirStructType } from "../TirStructType.js";
-import { TirNamedDestructableType, TirType } from "../TirType.js";
-export declare enum CanAssign {
-    LeftArgIsNotConcrete = -1,
-    No = 0,
-    Yes = 1,
-    LiftToOptional = 2,
-    RequiresExplicitCast = 3
-}
-export declare function isStructOrStructAlias(type: TirType): boolean;
-export declare function getStructType(type: TirType | undefined): TirStructType | undefined;
-export declare function getNamedDestructableType(type: TirType | undefined): TirNamedDestructableType | undefined;
-export declare function canAssignToOptional(type: TirType): type is TirDataOptT | TirSopOptT | TirAliasType<TirDataOptT | TirSopOptT>;
-export declare function canAssignToList(type: TirType): boolean;
-/**
- * @returns `true` if `a` can be assigned to `b` **without** explicit cast
- *
- * use `getCanAssign` for more detailed information
- */
-export declare function canAssignTo(a: TirType, b: TirType): boolean;
-export declare function getCanAssign(a: TirType, b: TirType): CanAssign;

package/dist/compiler/tir/types/utils/canAssignTo.js

@@ -1,337 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirUnConstrDataResultT, TirPairDataT } from "../TirNativeType/index.js";
-import { TirBoolT } from "../TirNativeType/native/bool.js";
-import { TirBytesT } from "../TirNativeType/native/bytes.js";
-import { TirDataT } from "../TirNativeType/native/data.js";
-import { TirFuncT } from "../TirNativeType/native/function.js";
-import { TirIntT } from "../TirNativeType/native/int.js";
-import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
-import { TirListT } from "../TirNativeType/native/list.js";
-import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
-import { TirStringT } from "../TirNativeType/native/string.js";
-import { TirVoidT } from "../TirNativeType/native/void.js";
-import { isTirStructType, TirDataStructType, TirSoPStructType } from "../TirStructType.js";
-import { isTirNamedDestructableType } from "../TirType.js";
-import { TirTypeParam } from "../TirTypeParam.js";
-import { canCastToData } from "./canCastTo.js";
-import { getUnaliased } from "./getUnaliased.js";
-export var CanAssign;
-(function (CanAssign) {
-    CanAssign[CanAssign["LeftArgIsNotConcrete"] = -1] = "LeftArgIsNotConcrete";
-    CanAssign[CanAssign["No"] = 0] = "No";
-    CanAssign[CanAssign["Yes"] = 1] = "Yes";
-    // yes, but...
-    CanAssign[CanAssign["LiftToOptional"] = 2] = "LiftToOptional";
-    CanAssign[CanAssign["RequiresExplicitCast"] = 3] = "RequiresExplicitCast";
-    // OnlyAsData,
-    // runtimeModifier,
-})(CanAssign || (CanAssign = {}));
-Object.freeze(CanAssign);
-export function isStructOrStructAlias(type) {
-    while (type instanceof TirAliasType)
-        type = type.aliased;
-    return isTirStructType(type);
-}
-export function getStructType(type) {
-    while (type instanceof TirAliasType)
-        type = type.aliased;
-    return isTirStructType(type) ? type : undefined;
-}
-export function getNamedDestructableType(type) {
-    while (type instanceof TirAliasType)
-        type = type.aliased;
-    if (!isTirNamedDestructableType(type))
-        return undefined;
-    return type;
-}
-export function canAssignToOptional(type) {
-    type = getUnaliased(type);
-    return (type instanceof TirDataOptT
-        || type instanceof TirSopOptT);
-}
-export function canAssignToList(type) {
-    type = getUnaliased(type);
-    return (type instanceof TirListT
-    // || type instanceof TirLinearMapT
-    );
-}
-/**
- * @returns `true` if `a` can be assigned to `b` **without** explicit cast
- *
- * use `getCanAssign` for more detailed information
- */
-export function canAssignTo(a, b) {
-    return getCanAssign(a, b) === CanAssign.Yes;
-}
-export function getCanAssign(a, b) {
-    // remove for tests
-    if (a === b)
-        return CanAssign.Yes; // same object, we don't care if not concrete
-    if (!a.isConcrete())
-        return CanAssign.LeftArgIsNotConcrete;
-    return uncheckedGetCanAssign(a, b, new Map());
-}
-function uncheckedGetCanAssign(a, b, symbols) {
-    // remove for tests
-    if (a === b)
-        return CanAssign.Yes; // same object (here for recursive calls)
-    // unwrap all aliases
-    // aliases are only for custom interface implementations
-    // but the data is the same
-    while (a instanceof TirAliasType)
-        a = a.aliased;
-    while (b instanceof TirAliasType)
-        b = b.aliased;
-    if (b instanceof TirTypeParam) {
-        if (symbols.has(b.symbol)) {
-            return uncheckedGetCanAssign(a, symbols.get(b.symbol), symbols);
-        }
-        symbols.set(b.symbol, a);
-        return CanAssign.Yes;
-    }
-    if (b instanceof TirVoidT) {
-        if (a instanceof TirVoidT)
-            return CanAssign.Yes;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirBoolT) {
-        if (a instanceof TirBoolT)
-            return CanAssign.Yes;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirIntT) {
-        if (a instanceof TirIntT)
-            return CanAssign.Yes;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirBytesT) {
-        if (a instanceof TirBytesT)
-            return CanAssign.Yes;
-        if (a instanceof TirStringT)
-            return CanAssign.RequiresExplicitCast;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirStringT) {
-        if (a instanceof TirStringT)
-            return CanAssign.Yes;
-        if (a instanceof TirBytesT)
-            return CanAssign.RequiresExplicitCast;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirUnConstrDataResultT) {
-        return a instanceof TirUnConstrDataResultT ? CanAssign.Yes : CanAssign.No;
-    }
-    if (b instanceof TirPairDataT) {
-        return a instanceof TirPairDataT ? CanAssign.Yes : CanAssign.No;
-    }
-    if (b instanceof TirSopOptT) {
-        if (a instanceof TirSopOptT)
-            return uncheckedGetCanAssign(a.typeArg, b.typeArg, symbols);
-        if (a instanceof TirDataOptT)
-            return canAssignTo(a.typeArg, b.typeArg) ? CanAssign.RequiresExplicitCast : CanAssign.No;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        const canAssingToDefined = uncheckedGetCanAssign(a, b.typeArg, symbols);
-        switch (canAssingToDefined) {
-            case CanAssign.Yes: // value => Some{ value }
-                return CanAssign.LiftToOptional;
-            case CanAssign.RequiresExplicitCast:
-            // TODO: do we want to allow this?
-            // return CanAssign.RequiresExplicitCast;
-            case CanAssign.No:
-            case CanAssign.LeftArgIsNotConcrete:
-            case CanAssign.LiftToOptional: // value is not assignable with single lift
-            default:
-                return CanAssign.No;
-        }
-        return CanAssign.No;
-    }
-    if (b instanceof TirDataOptT) {
-        if (a instanceof TirSopOptT)
-            return uncheckedGetCanAssign(a.typeArg, b.typeArg, symbols);
-        if (a instanceof TirDataOptT)
-            return canAssignTo(a.typeArg, b.typeArg) ? CanAssign.RequiresExplicitCast : CanAssign.No;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirListT) {
-        if (a instanceof TirListT)
-            return uncheckedGetCanAssign(a.typeArg, b.typeArg, symbols);
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirLinearMapT) {
-        if (a instanceof TirLinearMapT) {
-            return decideCanAssignField(uncheckedGetCanAssign(a.keyTypeArg, b.keyTypeArg, symbols), uncheckedGetCanAssign(a.valTypeArg, b.valTypeArg, symbols));
-        }
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirDataT) {
-        if (a instanceof TirDataT)
-            return CanAssign.Yes;
-        if (a instanceof TirDataStructType)
-            return CanAssign.RequiresExplicitCast;
-        if (a instanceof TirSoPStructType)
-            return CanAssign.No;
-        // int, bytes, string, bool, even void
-        // optionals (part of the standard ledger API) as long as the type argument can too
-        // structs that allow data encoding
-        // lists and maps of any of the above
-        // can all cast to data
-        return canCastToData(a) ? CanAssign.RequiresExplicitCast : CanAssign.No;
-    }
-    if (b instanceof TirDataStructType) {
-        if (a instanceof TirDataStructType)
-            return canAssignStruct(a, b, symbols);
-        if (a instanceof TirSoPStructType)
-            return CanAssign.No;
-        if (a instanceof TirDataT)
-            return CanAssign.RequiresExplicitCast;
-        return CanAssign.No;
-    }
-    if (b instanceof TirSoPStructType) {
-        if (a instanceof TirSoPStructType)
-            return canAssignStruct(a, b, symbols);
-        return CanAssign.No;
-    }
-    if (isTirStructType(a))
-        return CanAssign.No;
-    if (b instanceof TirFuncT) {
-        if (!(a instanceof TirFuncT
-            && a.argTypes.length === b.argTypes.length))
-            return CanAssign.No;
-        let currentDecision = uncheckedGetCanAssign(a.returnType, b.returnType, symbols);
-        for (let i = 0; i < a.argTypes.length; i++) {
-            currentDecision = decideCanAssignField(currentDecision, 
-            // TODO make one only for functions
-            uncheckedGetCanAssign(a.argTypes[i], b.argTypes[i], symbols));
-            if (currentDecision <= CanAssign.No)
-                return currentDecision;
-        }
-        return currentDecision;
-    }
-    const tsEnsureExsautstiveCheck = b;
-    return CanAssign.No;
-}
-function canAssignStruct(a, b, symbols) {
-    while (a instanceof TirAliasType)
-        a = a.aliased;
-    while (b instanceof TirAliasType)
-        b = b.aliased;
-    const aCtors = a.constructors;
-    const bCtors = b.constructors;
-    if (aCtors.length !== bCtors.length)
-        return CanAssign.No;
-    const len = aCtors.length;
-    // check for the same number of fields
-    // so we avoid useless checks on types that don't exsist
-    for (let i = 0; i < len; i++) {
-        const aCtor = aCtors[i];
-        const bCtor = bCtors[i];
-        if (aCtor.fields.length !== bCtor.fields.length)
-            return CanAssign.No;
-    }
-    for (let i = 0; i < len; i++) {
-        if (
-        // check for the same fields and the extending types to extend the given struct ones
-        !canAssignCtorDef(aCtors[i], bCtors[i], symbols))
-            return CanAssign.No;
-    }
-    // check if cast is needed even if shape is the same
-    for (let i = 0; i < len; i++) {
-        const aCtor = aCtors[i];
-        const bCtor = bCtors[i];
-        if (aCtor.fields.length !== bCtor.fields.length)
-            return CanAssign.RequiresExplicitCast;
-    }
-    if (a.name !== b.name)
-        return CanAssign.RequiresExplicitCast;
-    return CanAssign.Yes;
-}
-/**
- *
- * @param a extending ctor
- * @param b extended ctor
- * @returns
- */
-function canAssignCtorDef(a, b, symbols) {
-    if (a.fields.length !== b.fields.length)
-        return CanAssign.No;
-    const len = a.fields.length;
-    let currentDecision = CanAssign.Yes;
-    let prevDecision = currentDecision;
-    for (let i = 0; i < len; i++) {
-        prevDecision = currentDecision;
-        currentDecision = decideCanAssignField(currentDecision, uncheckedGetCanAssign(a.fields[i].type, b.fields[i].type, symbols));
-        if (currentDecision <= CanAssign.No)
-            return currentDecision;
-        if (a.fields[i].name !== b.fields[i].name)
-            currentDecision = decideCanAssignField(currentDecision, CanAssign.RequiresExplicitCast);
-    }
-    return currentDecision;
-}
-function decideCanAssignField(currentDecision, fieldDecision) {
-    if (currentDecision === CanAssign.No
-        || currentDecision === CanAssign.LeftArgIsNotConcrete)
-        return currentDecision;
-    switch (fieldDecision) {
-        // lift to optional only valid for direct types
-        case CanAssign.LiftToOptional: return CanAssign.No;
-        // no decisions always win
-        case CanAssign.No: return CanAssign.No;
-        case CanAssign.LeftArgIsNotConcrete: return CanAssign.LeftArgIsNotConcrete;
-        // yes decisions by most descriptive (sop and data conflict become nos)
-        case CanAssign.Yes: return currentDecision;
-        case CanAssign.RequiresExplicitCast: {
-            switch (currentDecision) {
-                case CanAssign.Yes: return CanAssign.RequiresExplicitCast;
-                case CanAssign.RequiresExplicitCast: return CanAssign.RequiresExplicitCast;
-                // case CanAssign.OnlyAsData: return CanAssign.OnlyAsData;
-                // case CanAssign.runtimeModifier: return CanAssign.runtimeModifier;
-                default: return CanAssign.No;
-            }
-            break;
-        }
-        // case CanAssign.OnlyAsData: {
-        //     switch( currentDecision )
-        //     {
-        //         case CanAssign.Yes: return CanAssign.OnlyAsData;
-        //         case CanAssign.RequiresExplicitCast: return CanAssign.OnlyAsData;
-        //         case CanAssign.OnlyAsData: return CanAssign.OnlyAsData;
-        //         case CanAssign.runtimeModifier: return CanAssign.No; // conflict
-        //         default: return CanAssign.No;
-        //     }
-        //     break;
-        // }
-        // case CanAssign.runtimeModifier: {
-        //     switch( currentDecision )
-        //     {
-        //         case CanAssign.Yes: return CanAssign.runtimeModifier;
-        //         case CanAssign.RequiresExplicitCast: return CanAssign.runtimeModifier;
-        //         // case CanAssign.OnlyAsData: return CanAssign.No; // conflict
-        //         case CanAssign.runtimeModifier: return CanAssign.runtimeModifier;
-        //         default: return CanAssign.No;
-        //     }
-        //     break;
-        // }
-        default:
-            // never
-            // fieldDecision; 
-            return CanAssign.No;
-    }
-}

package/dist/compiler/tir/types/utils/canCastTo.d.ts

@@ -1,9 +0,0 @@
-import { TirType } from "../TirType.js";
-export declare function canCastTo(a: TirType, b: TirType): boolean;
-/**
- * int, bytes, string, bool, even void
- * lists and maps of any of the above
- * optionals (part of the standard ledger API) as long as the type argument can too
- * can all cast to data
- */
-export declare function canCastToData(a: TirType): boolean;

package/dist/compiler/tir/types/utils/canCastTo.js

@@ -1,155 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirBoolT } from "../TirNativeType/native/bool.js";
-import { TirBytesT } from "../TirNativeType/native/bytes.js";
-import { TirDataT } from "../TirNativeType/native/data.js";
-import { TirFuncT } from "../TirNativeType/native/function.js";
-import { TirIntT } from "../TirNativeType/native/int.js";
-import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
-import { TirListT } from "../TirNativeType/native/list.js";
-import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
-import { TirStringT } from "../TirNativeType/native/string.js";
-import { TirVoidT } from "../TirNativeType/native/void.js";
-import { isTirStructType, TirDataStructType } from "../TirStructType.js";
-import { CanAssign, getCanAssign } from "./canAssignTo.js";
-export function canCastTo(a, b) {
-    if (!(a.isConcrete()
-        && b.isConcrete()))
-        return false; // both need to be concrete
-    while (b instanceof TirAliasType)
-        b = b.aliased;
-    while (a instanceof TirAliasType)
-        a = a.aliased;
-    if (b instanceof TirDataT) {
-        return canCastToData(a);
-    }
-    if (isTirStructType(b)) {
-        switch (getCanAssign(a, b)) {
-            case CanAssign.Yes:
-            // case CanAssign.runtimeModifier:
-            // case CanAssign.OnlyAsData:
-            case CanAssign.RequiresExplicitCast:
-                return true;
-            case CanAssign.No:
-            case CanAssign.LeftArgIsNotConcrete:
-            default:
-                return false;
-        }
-    }
-    if (b instanceof TirVoidT) {
-        return (a instanceof TirVoidT
-            || a instanceof TirDataT // Constr( 0, [] ) // void is unit
-        );
-    }
-    if (b instanceof TirBoolT) {
-        return (a instanceof TirBoolT
-            || a instanceof TirDataT
-            || a instanceof TirIntT
-            || a instanceof TirSopOptT
-            || a instanceof TirDataOptT);
-    }
-    if (b instanceof TirIntT) {
-        if (a instanceof TirIntT)
-            return true;
-        if (a instanceof TirDataT)
-            return true;
-        if (a instanceof TirBoolT)
-            return true; // 0 | 1
-        if (a instanceof TirBytesT)
-            return true; // decode big endian plutus v3 builtin
-        return false;
-    }
-    if (b instanceof TirBytesT) {
-        if (a instanceof TirBytesT)
-            return true;
-        if (a instanceof TirDataT)
-            return true;
-        if (a instanceof TirStringT)
-            return true; // string -> bytes // decode utf8
-        // how do we handle this?
-        // in theory we can encode but only fixed size
-        // we have no idea of the size of ints
-        // if( a instanceof TirIntT ) return true;
-        return false;
-    }
-    if (b instanceof TirStringT) {
-        if (a instanceof TirStringT)
-            return true;
-        if (a instanceof TirDataT)
-            return true;
-        if (a instanceof TirBytesT)
-            return true; // bytes -> string // encode utf8
-        return false;
-    }
-    if (b instanceof TirDataOptT
-        || b instanceof TirSopOptT) {
-        if (a instanceof TirDataOptT
-            || a instanceof TirSopOptT)
-            return canCastTo(a.typeArg, b.typeArg);
-        if (a instanceof TirDataT)
-            return true;
-        return false;
-    }
-    if (b instanceof TirListT) {
-        if (a instanceof TirListT)
-            return canCastTo(a.typeArg, b.typeArg);
-        if (a instanceof TirDataT)
-            return canCastToData(b.typeArg);
-        return false;
-    }
-    if (b instanceof TirLinearMapT) {
-        if (a instanceof TirLinearMapT) {
-            return (canCastTo(a.keyTypeArg, b.keyTypeArg)
-                && canCastTo(a.valTypeArg, b.valTypeArg));
-        }
-        if (a instanceof TirDataT)
-            return (canCastToData(b.keyTypeArg)
-                && canCastToData(b.valTypeArg));
-        return false;
-    }
-    if (b instanceof TirFuncT) {
-        if (!(a instanceof TirFuncT))
-            return false;
-        return (a.argTypes.length === b.argTypes.length
-            && a.argTypes.every((arg, i) => getCanAssign(arg, b.argTypes[i]) === CanAssign.Yes)
-            && getCanAssign(a.returnType, b.returnType) === CanAssign.Yes);
-    }
-    // TirTypeParam
-    // b;
-    return false;
-}
-/**
- * int, bytes, string, bool, even void
- * lists and maps of any of the above
- * optionals (part of the standard ledger API) as long as the type argument can too
- * can all cast to data
- */
-export function canCastToData(a) {
-    while (a instanceof TirAliasType
-        || a instanceof TirSopOptT
-        || a instanceof TirDataOptT
-        || a instanceof TirListT) {
-        if (a instanceof TirAliasType)
-            a = a.aliased;
-        if (a instanceof TirListT
-            || a instanceof TirSopOptT)
-            a = a.typeArg;
-    }
-    if (a instanceof TirDataT
-        || a instanceof TirVoidT
-        || a instanceof TirIntT
-        || a instanceof TirBytesT
-        || a instanceof TirStringT
-        || a instanceof TirBoolT
-        || a instanceof TirDataOptT
-        || a instanceof TirDataStructType)
-        return true;
-    if (a instanceof TirLinearMapT) {
-        const key = canCastToData(a.keyTypeArg);
-        const value = canCastToData(a.valTypeArg);
-        return key && value;
-    }
-    // TirFuncT | TirSoPStructType | TirTypeParam
-    a;
-    return false;
-}

package/dist/compiler/tir/types/utils/getDeconstructableType.d.ts

@@ -1,9 +0,0 @@
-import { TirDataT } from "../TirNativeType/native/data.js";
-import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
-import { TirListT } from "../TirNativeType/native/list.js";
-import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
-import { TirStructType } from "../TirStructType.js";
-import { TirType } from "../TirType.js";
-export type DeconstructableTirType = TirStructType | TirSopOptT | TirDataOptT | TirListT | TirLinearMapT | TirDataT;
-export declare function getDeconstructableType(type: TirType): DeconstructableTirType | undefined;

package/dist/compiler/tir/types/utils/getDeconstructableType.js

@@ -1,20 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirDataT } from "../TirNativeType/native/data.js";
-import { TirLinearMapT } from "../TirNativeType/native/linearMap.js";
-import { TirListT } from "../TirNativeType/native/list.js";
-import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
-import { isTirStructType } from "../TirStructType.js";
-export function getDeconstructableType(type) {
-    while (type instanceof TirAliasType)
-        type = type.aliased;
-    if (isTirStructType(type)
-        || type instanceof TirSopOptT
-        || type instanceof TirDataOptT
-        || type instanceof TirListT
-        || type instanceof TirLinearMapT
-        || type instanceof TirDataT // builtin choose data
-    )
-        return type;
-    return undefined;
-}

package/dist/compiler/tir/types/utils/getListTypeArg.d.ts

@@ -1,2 +0,0 @@
-import { TirType } from "../TirType.js";
-export declare function getListTypeArg(list_t: TirType): TirType | undefined;

package/dist/compiler/tir/types/utils/getListTypeArg.js

@@ -1,9 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirListT } from "../TirNativeType/native/list.js";
-export function getListTypeArg(list_t) {
-    while (list_t instanceof TirAliasType)
-        list_t = list_t.aliased;
-    if (list_t instanceof TirListT)
-        return list_t.typeArg;
-    return undefined;
-}

package/dist/compiler/tir/types/utils/getOptTypeArg.d.ts

@@ -1,2 +0,0 @@
-import { TirType } from "../TirType.js";
-export declare function getOptTypeArg(opt_t: TirType): TirType | undefined;

package/dist/compiler/tir/types/utils/getOptTypeArg.js

@@ -1,14 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirDataOptT } from "../TirNativeType/native/Optional/data.js";
-import { TirSopOptT } from "../TirNativeType/native/Optional/sop.js";
-import { isTirType } from "../TirType.js";
-export function getOptTypeArg(opt_t) {
-    if (!isTirType(opt_t))
-        throw new Error("getOptTypeArg: not a TirType");
-    while (opt_t instanceof TirAliasType)
-        opt_t = opt_t.aliased;
-    if (opt_t instanceof TirSopOptT
-        || opt_t instanceof TirDataOptT)
-        return opt_t.typeArg;
-    return undefined;
-}

package/dist/compiler/tir/types/utils/getUnaliased.d.ts

@@ -1,3 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { TirType } from "../TirType.js";
-export declare function getUnaliased(t: TirType): Exclude<TirType, TirAliasType<any>>;

package/dist/compiler/tir/types/utils/getUnaliased.js

@@ -1,9 +0,0 @@
-import { TirAliasType } from "../TirAliasType.js";
-import { isTirType } from "../TirType.js";
-export function getUnaliased(t) {
-    if (!isTirType(t))
-        throw new Error(`getUnaliased: expected a TirType, got ${t}`);
-    while (t instanceof TirAliasType)
-        t = t.aliased;
-    return t;
-}