@shd101wyy/yo 0.0.2

package/out/types/src/types/creators.d.ts

@@ -0,0 +1,73 @@
+import { Environment, Frame } from "../env";
+import { Expr } from "../expr";
+import { FunctionValue } from "../function-value";
+import { Value } from "../value";
+import { ArrayType, ComptListType, DynType, EnumType, FnModuleType, FunctionForallParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureModuleType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TupleType, Type, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+export declare function createComptIntType(): Type;
+export declare function createComptFloatType(): Type;
+export declare function createComptStringType(): Type;
+export declare function createExprType(): Type;
+export declare function createComptListType(childType: Type): ComptListType;
+export declare function createExprListType(): Type;
+export declare function createBooleanType(): Type;
+export declare function createUsizeType(): Type;
+export declare function createIsizeType(): Type;
+export declare function createU8Type(): Type;
+export declare function createI8Type(): Type;
+export declare function createU16Type(): Type;
+export declare function createI16Type(): Type;
+export declare function createU32Type(): Type;
+export declare function createI32Type(): Type;
+export declare function createU64Type(): Type;
+export declare function createI64Type(): Type;
+export declare function createF32Type(): Type;
+export declare function createF64Type(): Type;
+export declare function createUnitType(): Type;
+export declare function createCharType(): Type;
+export declare function createShortType(): Type;
+export declare function createUShortType(): Type;
+export declare function createIntType(): Type;
+export declare function createUIntType(): Type;
+export declare function createLongType(): Type;
+export declare function createULongType(): Type;
+export declare function createLongLongType(): Type;
+export declare function createULongLongType(): Type;
+export declare function createLongDoubleType(): Type;
+export declare function createType0(baseType?: Type): TypeHierarchyType;
+export declare function createArrayType(childType: Type, length: Value): ArrayType;
+export declare function createSliceType(childType: Type): SliceType;
+export declare function createVoidType(): VoidType;
+export declare function createTupleType(fields: TypeField[]): TupleType;
+export declare function createStructType(env: Environment, isReferenceSemantics?: boolean, isNewtype?: boolean): StructType;
+export declare function createModuleType(env: Environment): ModuleType;
+export declare function createEnumType(env: Environment): EnumType;
+export declare function createUnionType(env: Environment): UnionType;
+export declare function createFunctionType({ parameters, forallParameters, variadicParameter, return_, env, parametersFrame, SelfType, ParentFunctionType, isClosure, }: {
+    parameters: FunctionParameter[];
+    forallParameters: FunctionForallParameter[];
+    variadicParameter: FunctionParameter | undefined;
+    return_: FunctionReturn;
+    env: Environment;
+    parametersFrame: Frame;
+    SelfType?: Type;
+    ParentFunctionType?: FunctionType;
+    isClosure?: boolean;
+}): FunctionType;
+export declare function createPtrType(childType: Type): PtrType;
+export declare function createIsoType(childType: Type, env: Environment): IsoType;
+export declare function createSomeType(type: TypeHierarchyType, variableName: string, id?: string, requiredModules?: ModuleType[], negativeModules?: ModuleType[], recursiveTypeRef?: {
+    functionValue: FunctionValue;
+    argValues: Value[];
+}): SomeType;
+export declare function createTypeHierarchy(level: number, baseType?: Type): TypeHierarchyType;
+export declare function getFunctionParameterExprs({ expr, labelExpr, typeExpr, defaultValueExpr, assignedValueExpr, }: {
+    expr: Expr;
+    labelExpr: Expr | undefined;
+    typeExpr: Expr | undefined;
+    defaultValueExpr: Expr | undefined;
+    assignedValueExpr: Expr | undefined;
+}): FunctionParameterExprs;
+export declare function createFnModuleType(fnType: FunctionType, env: Environment): FnModuleType;
+export declare function createFutureModuleType(outputType: Type, env: Environment): FutureModuleType;
+export declare function createDynType(requiredModules: ModuleType[], env: Environment, negativeModules?: ModuleType[]): DynType;
+export declare function clearAllCachedTypes(): void;

package/out/types/src/types/definitions.d.ts

@@ -0,0 +1,218 @@
+import { Environment, Frame } from "../env";
+import { Expr } from "../expr";
+import { FunctionValue } from "../function-value";
+import { Value } from "../value";
+import { TypeTag } from "./tags";
+export type TypeId = string;
+export type ExternLanguage = "yo" | "c";
+export interface Type {
+    tag: TypeTag;
+    id: TypeId;
+    typeName?: string;
+    isExtern?: ExternLanguage;
+    externName?: string;
+    cInclude?: string;
+    module?: ModuleType;
+    definedInModulePath?: string;
+}
+export interface ExprType extends Type {
+    tag: TypeTag.Expr;
+    id: TypeTag.Expr;
+    module: ModuleType;
+}
+export interface ComptListType extends Type {
+    tag: TypeTag.ComptList;
+    childType: Type;
+    module: ModuleType;
+}
+export interface TypeHierarchyType extends Type {
+    tag: TypeTag.Type;
+    level: number;
+    baseType?: Type;
+    module: ModuleType;
+}
+export interface SomeType extends Type {
+    tag: TypeTag.SomeType;
+    name: string;
+    parentType: TypeHierarchyType;
+    size: undefined;
+    functionApplication?: Expr;
+    resolvedConcreteType?: Type;
+    requiredModules: ModuleType[];
+    negativeModules?: ModuleType[];
+    module: ModuleType;
+    recursiveTypeRef?: {
+        functionValue: FunctionValue;
+        argValues: Value[];
+    };
+}
+export interface ArrayType extends Type {
+    tag: TypeTag.Array;
+    childType: Type;
+    length: Value;
+    module: ModuleType;
+}
+export interface SliceType extends Type {
+    tag: TypeTag.Slice;
+    childType: Type;
+    module: ModuleType;
+}
+export interface VoidType extends Type {
+    tag: TypeTag.Void;
+    module: ModuleType;
+}
+export type ElementExprs = {
+    expr: Expr;
+    labelExpr?: Expr;
+    typeExpr?: Expr;
+    defaultValueExpr?: Expr;
+    assignedValueExpr?: Expr;
+};
+export interface TypeField {
+    type: Type;
+    label: string;
+    isCompileTimeOnly: boolean;
+    defaultValue?: Value;
+    assignedValue?: Value;
+    exprs: ElementExprs;
+}
+export interface TupleType extends Type {
+    tag: TypeTag.Tuple;
+    fields: TypeField[];
+    module: ModuleType;
+}
+export type FunctionParameterExprs = {
+    expr: Expr;
+    labelExpr?: Expr;
+    typeExpr?: Expr;
+    defaultValueExpr?: Expr;
+    assignedValueExpr?: Expr;
+};
+export interface FunctionParameter {
+    label: string;
+    type: Type;
+    isCompileTimeOnly: boolean;
+    isQuote: boolean;
+    isOwningTheGcValue: boolean;
+    exprs: FunctionParameterExprs;
+    assignedValue?: Value;
+}
+export type FunctionForallParameter = FunctionParameter & {
+    isCompileTimeOnly: true;
+};
+export interface StructType extends Type {
+    tag: TypeTag.Struct;
+    isReferenceSemantics: boolean;
+    isNewtype: boolean;
+    functionValue?: FunctionValue;
+    fields: TypeField[];
+    module: ModuleType;
+    env: Environment;
+}
+export interface ModuleField {
+    type: Type;
+    label: string;
+    isCompileTimeOnly: true;
+    sourceModulePath?: string;
+    defaultValue?: Value;
+    assignedValue?: Value;
+    exprs: ElementExprs;
+}
+export interface ModuleType extends Type {
+    tag: TypeTag.Module;
+    functionValue?: FunctionValue;
+    fields: ModuleField[];
+    module: undefined;
+    env: Environment;
+    receiverType?: Type;
+    isNegatedConstraint?: boolean;
+    selfConstraints?: ModuleType[];
+    negativeSelfConstraints?: ModuleType[];
+    isFn?: {
+        callType: FunctionType;
+    };
+    isFuture?: {
+        outputType: Type;
+    };
+    isConcrete?: {
+        concreteType: Type;
+    };
+    definedInModulePath?: string;
+}
+export type FnModuleType = ModuleType & {
+    isFn: {
+        callType: FunctionType;
+    };
+};
+export type FutureModuleType = ModuleType & {
+    isFuture: {
+        outputType: Type;
+    };
+};
+export type ConcreteModuleType = ModuleType & {
+    isConcrete: {
+        concreteType: Type;
+    };
+};
+export interface EnumVariant {
+    name: string;
+    fields?: TypeField[];
+}
+export interface EnumType extends Type {
+    tag: TypeTag.Enum;
+    functionValue?: FunctionValue;
+    variants: EnumVariant[];
+    module: ModuleType;
+    env: Environment;
+    selectedVariantName?: string;
+    requiredVariantNames?: string[];
+}
+export interface UnionType extends Type {
+    tag: TypeTag.Union;
+    functionValue?: FunctionValue;
+    fields: TypeField[];
+    module: ModuleType;
+    env: Environment;
+}
+export interface FunctionReturn {
+    type: Type;
+    expr?: Expr;
+    isCompileTimeOnly: boolean;
+    isUnquote: boolean;
+    label: string;
+}
+export interface FunctionType extends Type {
+    tag: TypeTag.Function;
+    parameters: FunctionParameter[];
+    forallParameters: FunctionForallParameter[];
+    variadicParameter?: FunctionParameter;
+    return: FunctionReturn;
+    env: Environment;
+    parametersFrame: Frame;
+    SelfType?: Type;
+    ParentFunctionType?: FunctionType;
+    module: ModuleType;
+    isClosure?: boolean;
+    whereClauseConstraints?: Map<SomeType, {
+        requiredModules: ModuleType[];
+        negativeModules: ModuleType[];
+    }>;
+}
+export interface PtrType extends Type {
+    tag: TypeTag.Ptr;
+    childType: Type;
+    module: ModuleType;
+}
+export interface IsoType extends Type {
+    tag: TypeTag.Iso;
+    childType: Type;
+    module: ModuleType;
+    env: Environment;
+}
+export interface DynType extends Type {
+    tag: TypeTag.Dyn;
+    requiredModules: ModuleType[];
+    negativeModules?: ModuleType[];
+    module: ModuleType;
+    env: Environment;
+}

package/out/types/src/types/guards.d.ts

@@ -0,0 +1,70 @@
+import { ArrayType, ComptListType, ConcreteModuleType, DynType, EnumType, FnModuleType, FunctionType, FutureModuleType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TupleType, Type, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+export declare function isPrimitiveType(type: Type): boolean;
+export declare function isUnitType(type?: Type): boolean;
+export declare function isComptIntType(type?: Type): boolean;
+export declare function isComptFloatType(type?: Type): boolean;
+export declare function isComptStringType(type?: Type): boolean;
+export declare function isComptListType(type?: Type): type is ComptListType;
+export declare function isExprListType(type?: Type): boolean;
+export declare function isBooleanType(type?: Type): boolean;
+export declare function isUsizeType(type?: Type): boolean;
+export declare function isIsizeType(type?: Type): boolean;
+export declare function isU8Type(type?: Type): boolean;
+export declare function isI8Type(type?: Type): boolean;
+export declare function isU16Type(type?: Type): boolean;
+export declare function isI16Type(type?: Type): boolean;
+export declare function isU32Type(type?: Type): boolean;
+export declare function isI32Type(type?: Type): boolean;
+export declare function isU64Type(type?: Type): boolean;
+export declare function isI64Type(type?: Type): boolean;
+export declare function isF32Type(type?: Type): boolean;
+export declare function isF64Type(type?: Type): boolean;
+export declare function isExprType(type?: Type): boolean;
+export declare function isArrayType(type?: Type): type is ArrayType;
+export declare function isSliceType(type?: Type): type is SliceType;
+export declare function isTupleType(type?: Type): type is TupleType;
+export declare function isUnionType(type?: Type): type is UnionType;
+export declare function isEnumType(type?: Type): type is EnumType;
+export declare function isStructType(type?: Type): type is StructType;
+export declare function isObjectType(type?: Type): type is StructType & {
+    isReferenceSemantics: true;
+};
+export declare function isNewtypeType(type?: Type): type is StructType & {
+    isNewtype: true;
+};
+export declare function isModuleType(type?: Type): type is ModuleType;
+export declare function isFnModuleType(type?: Type): type is FnModuleType;
+export declare function isFunctionType(type?: Type): type is FunctionType;
+export declare function isFunctionTypeAndIsTypeFunction(type?: Type): boolean;
+export declare function isFunctionTypeAndIsMacroFunction(type?: Type): boolean;
+export declare function isFunctionTypeAndReturnsComptValue(type?: Type): boolean;
+export declare function isTypeHierarchyType(type?: Type): type is TypeHierarchyType;
+export declare function isType0(type?: Type): boolean;
+export declare function isSomeType(type?: Type): type is SomeType;
+export declare function isPtrType(type?: Type): type is PtrType;
+export declare function isIsoType(type?: Type): type is IsoType;
+export declare function isDynType(type?: Type): type is DynType;
+export declare function isGcType(type?: Type): boolean;
+export declare function isIntegerType(type?: Type): boolean;
+export declare function isFloatType(type?: Type): boolean;
+export declare function isSignedIntegerType(type?: Type): boolean;
+export declare function isUnsignedIntegerType(type?: Type): boolean;
+export declare function isCharType(type?: Type): boolean;
+export declare function isShortType(type?: Type): boolean;
+export declare function isUShortType(type?: Type): boolean;
+export declare function isIntType(type?: Type): boolean;
+export declare function isUIntType(type?: Type): boolean;
+export declare function isLongType(type?: Type): boolean;
+export declare function isULongType(type?: Type): boolean;
+export declare function isLongLongType(type?: Type): boolean;
+export declare function isULongLongType(type?: Type): boolean;
+export declare function isLongDoubleType(type?: Type): boolean;
+export declare function isVoidType(type?: Type): type is VoidType;
+export declare function isFutureModuleType(type?: Type): type is FutureModuleType;
+export declare function isConcreteModuleType(type?: Type): type is ConcreteModuleType;
+export declare function isCCompatibleType(type?: Type): boolean;
+export declare function isFunctionSpecializable(functionType: FunctionType): boolean;
+export declare function isBoxedType(type: Type): type is StructType & {
+    isReferenceSemantics: true;
+    __isBoxed: true;
+};

package/out/types/src/types/hierarchy.d.ts

@@ -0,0 +1,4 @@
+import { Token } from "../token";
+import { FunctionParameter, Type, TypeField } from "./definitions";
+export declare function typeOfType(type: Type, checkedTupleElements?: TypeField[]): Type;
+export declare function getFunctionParameterToken(parameter: FunctionParameter): Token;

package/out/types/src/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./compatibility";
+export * from "./creators";
+export * from "./definitions";
+export * from "./guards";
+export * from "./hierarchy";
+export * from "./tags";
+export * from "./utils";

package/out/types/src/types/module_field.d.ts

@@ -0,0 +1,2 @@
+import { ModuleType } from "./definitions";
+export declare function addModuleFieldsByCode(module: ModuleType, elements: Record<string, string>): void;

package/out/types/src/types/tags.d.ts

@@ -0,0 +1,45 @@
+export declare enum TypeTag {
+    Unit = "unit",
+    Bool = "bool",
+    Usize = "usize",
+    Isize = "isize",
+    U8 = "u8",
+    I8 = "i8",
+    U16 = "u16",
+    I16 = "i16",
+    U32 = "u32",
+    I32 = "i32",
+    U64 = "u64",
+    I64 = "i64",
+    F32 = "f32",
+    F64 = "f64",
+    ComptInt = "compt_int",
+    ComptFloat = "compt_float",
+    ComptString = "compt_string",
+    Char = "char",
+    Short = "short",
+    UShort = "ushort",
+    Int = "int",
+    UInt = "uint",
+    Long = "long",
+    ULong = "ulong",
+    LongLong = "longlong",
+    ULongLong = "ulonglong",
+    LongDouble = "longdouble",
+    Void = "void",
+    Type = "Type",
+    Array = "Array",
+    Tuple = "Tuple",
+    Struct = "Struct",
+    Enum = "Enum",
+    Union = "Union",
+    Function = "Function",
+    SomeType = "SomeType",
+    Slice = "Slice",
+    Module = "Module",
+    Ptr = "Ptr",
+    Iso = "Iso",
+    Dyn = "Dyn",
+    Expr = "Expr",
+    ComptList = "ComptList"
+}

package/out/types/src/types/utils.d.ts

@@ -0,0 +1,50 @@
+import { Environment } from "../env";
+import { Expr } from "../expr";
+import { Token } from "../token";
+import { DynType, FnModuleType, FunctionParameter, FutureModuleType, ModuleType, SomeType, Type, TypeField } from "./definitions";
+export declare function getModuleTypeFromEnv(env: Environment, moduleName: string): ModuleType | undefined;
+export declare function typeImplementsModuleInternal({ targetType, moduleType, env, }: {
+    targetType: Type;
+    moduleType: ModuleType;
+    env: Environment;
+}): boolean;
+export declare function typeImplementsSend(type: Type | undefined, env: Environment): boolean;
+export declare function typeImplementsFn(type: Type | undefined): type is (SomeType | DynType) & {
+    isFn: true;
+};
+export declare function extractFnModuleFromType(type: Type): FnModuleType | undefined;
+export declare function typeImplementsFuture(type: Type | undefined): type is (SomeType | DynType) & {
+    isFuture: true;
+};
+export declare function extractFutureModuleFromType(type: Type): FutureModuleType | undefined;
+export declare function typeRequiresComptModifier(type?: Type): boolean;
+export declare function typeProhibitsComptModifier(type?: Type): boolean;
+export declare function typeContainsGcType(type?: Type, checkedTypes?: Type[]): boolean;
+export declare function typeContainsSomeType(type?: Type, checkedTypes?: Type[]): boolean;
+export declare function getAllSomeTypes(type: Type): Set<SomeType>;
+export declare function typeRequiresInference(type?: Type): boolean;
+export declare function getValueOfSomeTypeFromEnv(env: Environment, someType: SomeType): Type;
+export declare function convertComptTypeToRuntimeType({ type, expectedType, expr, env, }: {
+    type: Type;
+    expectedType?: Type;
+    expr?: Expr;
+    env: Environment;
+}): Type;
+export declare function getIntegerTypeBits(type: Type): number;
+export declare function getIntegerTypeRange(type: Type): {
+    min: bigint;
+    max: bigint;
+};
+export declare function canComptIntCastTo(targetType: Type): boolean;
+export declare function canComptFloatCastTo(targetType: Type): boolean;
+export declare function functionParameterToString(parameter: FunctionParameter, visited?: Set<string>): string;
+export declare function tupleFieldToString(element: TypeField, visited?: Set<string>): string;
+export declare function typeToString(type: Type, visited?: Set<string>): string;
+export declare function setTargetPointerSize(bits: number): void;
+export declare function getTargetPointerSizeBits(): number;
+export declare function getTargetPointerSizeBytes(): number;
+export declare function getAlignmentOfType(type: Type): number | null;
+export declare function getSizeOfType(type: Type): number | null;
+export declare function prohibitVoidType(type: Type, token: Token): void;
+export declare function canTypeFormGcCycle(type: Type, visitedTypes?: Set<string>): boolean;
+export declare function typeContainsSelfTypeForDynamicDispatchCheck(type: Type, selfType: Type | undefined): boolean;

package/out/types/src/unit-value.d.ts

@@ -0,0 +1,7 @@
+import { Type } from "./types";
+import { ValueTag } from "./value-tag";
+export type UnitValue = {
+    tag: ValueTag.Unit;
+    type: Type;
+};
+export declare const VUnit: UnitValue;

package/out/types/src/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function randomId(): string;
+export declare function generateModuleId(modulePath: string): string;
+export declare function generateNewTempVariableName(modulePath: string): string;
+export declare function isTempVariableName(modulePath: string, variableName: string): boolean;
+export declare function generateVarialeId(modulePath: string, variableName: string): string;
+export declare function hashString(input: string): string;

package/out/types/src/value-tag.d.ts

@@ -0,0 +1,29 @@
+export declare enum ValueTag {
+    Type = "Type",
+    ComptInt = "ComptInt",
+    ComptFloat = "ComptFloat",
+    ComptString = "ComptString",
+    U8 = "U8",
+    I8 = "I8",
+    U16 = "U16",
+    I16 = "I16",
+    U32 = "U32",
+    I32 = "I32",
+    U64 = "U64",
+    I64 = "I64",
+    F32 = "F32",
+    F64 = "F64",
+    Usize = "Usize",
+    Isize = "Isize",
+    Unit = "Unit",
+    Bool = "Bool",
+    Array = "Array",
+    Function = "Function",
+    Tuple = "Tuple",
+    Struct = "Struct",
+    Enum = "Enum",
+    Module = "Module",
+    Expr = "Expr",
+    ComptList = "ComptList",
+    Unknown = "Unknown"
+}

package/out/types/src/value.d.ts

@@ -0,0 +1,110 @@
+import { Environment } from "./env";
+import { Expr } from "./expr";
+import { FunctionValue } from "./function-value";
+import { TypeValue } from "./type-value";
+import { ArrayType, ComptListType, EnumType, ExprType, ModuleType, StructType, TupleType, Type } from "./types";
+import { UnitValue } from "./unit-value";
+import { ValueTag } from "./value-tag";
+export type ComptStringValue = {
+    tag: ValueTag.ComptString;
+    type: Type;
+    value: string;
+};
+export type NumberValue = {
+    tag: ValueTag.ComptInt | ValueTag.ComptFloat | ValueTag.U8 | ValueTag.I8 | ValueTag.U16 | ValueTag.I16 | ValueTag.U32 | ValueTag.I32 | ValueTag.U64 | ValueTag.I64 | ValueTag.F32 | ValueTag.F64 | ValueTag.Usize | ValueTag.Isize;
+    type: Type;
+    value: number;
+};
+export type BooleanValue = {
+    tag: ValueTag.Bool;
+    type: Type;
+    value: boolean;
+};
+export type TupleValue = {
+    tag: ValueTag.Tuple;
+    type: TupleType;
+    fields: Value[];
+};
+export type StructValue = {
+    tag: ValueTag.Struct;
+    type: StructType;
+    fields: Value[];
+};
+export type EnumValue = {
+    tag: ValueTag.Enum;
+    type: EnumType;
+    variantName: string;
+    fields: Value[];
+};
+export type ModuleValue = {
+    tag: ValueTag.Module;
+    type: ModuleType;
+    fields: (Value | undefined)[];
+};
+export type ArrayValue = {
+    tag: ValueTag.Array;
+    type: ArrayType;
+    elements: Value[];
+};
+export type ExprValue = {
+    tag: ValueTag.Expr;
+    type: ExprType;
+    value: Expr;
+};
+export type ComptListValue = {
+    tag: ValueTag.ComptList;
+    type: ComptListType;
+    elements: Value[];
+};
+export type UnknownValue = {
+    tag: ValueTag.Unknown;
+    type: Type;
+    variableName?: string;
+};
+export type Value = TypeValue | ComptStringValue | ComptListValue | NumberValue | UnitValue | BooleanValue | ArrayValue | TupleValue | StructValue | EnumValue | ModuleValue | FunctionValue | ExprValue | UnknownValue;
+export declare function valueToString(value?: Value): string;
+export declare function isTypeValue(value?: Value): value is TypeValue;
+export declare function isComptIntValue(value?: Value): value is NumberValue;
+export declare function isComptFloatValue(value?: Value): value is NumberValue;
+export declare function isComptStringValue(value?: Value): value is ComptStringValue;
+export declare function isComptListValue(value?: Value): value is ComptListValue;
+export declare function isExprListValue(value?: Value): value is ComptListValue;
+export declare function isNumberValue(value?: Value): value is NumberValue;
+export declare function isBooleanValue(value?: Value): value is BooleanValue;
+export declare function isFunctionValue(value?: Value): value is FunctionValue;
+export declare function isUnknownValue(value?: Value): value is UnknownValue;
+export declare function isTupleValue(value?: Value): value is TupleValue;
+export declare function isStructValue(value?: Value): value is StructValue;
+export declare function isArrayValue(value?: Value): value is ArrayValue;
+export declare function isEnumValue(value?: Value): value is EnumValue;
+export declare function isModuleValue(value?: Value): value is ModuleValue;
+export declare function isRegionValue(_value?: Value): boolean;
+export declare function isExprValue(value?: Value): value is ExprValue;
+export declare function createTypeValue(value: Type): TypeValue;
+export declare function createComptStringValue(value: string): ComptStringValue;
+export declare function createComptListValue(childType: Type, elements: Value[]): ComptListValue;
+export declare function createNumberValue(tag: NumberValue["tag"], value: number): {
+    tag: ValueTag.ComptInt | ValueTag.ComptFloat | ValueTag.U8 | ValueTag.I8 | ValueTag.U16 | ValueTag.I16 | ValueTag.U32 | ValueTag.I32 | ValueTag.U64 | ValueTag.I64 | ValueTag.F32 | ValueTag.F64 | ValueTag.Usize | ValueTag.Isize;
+    type: Type;
+    value: number;
+};
+export declare function createComptIntValue(value: number): NumberValue;
+export declare function createComptFloatValue(value: number): NumberValue;
+export declare function createBooleanValue(value: boolean): BooleanValue;
+export declare function createUnknownValue(type: Type, variableName?: string, recursiveTypeRef?: {
+    functionValue: FunctionValue;
+    argValues: Value[];
+}): UnknownValue | TypeValue;
+export declare function createStructValue(type: StructType, fields: Value[]): StructValue;
+export declare function createModuleValue(type: ModuleType, fields: (Value | undefined)[]): ModuleValue;
+export declare function createTupleValue(type: TupleType, fields: Value[]): TupleValue;
+export declare function createEnumValue(type: EnumType, variantName: string, fields: Value[]): EnumValue;
+export declare function createArrayValue(type: ArrayType, elements: Value[]): ArrayValue;
+export declare function createExprValue(expr: Expr): ExprValue;
+export declare function areValuesEqual(expected: {
+    value: Value | undefined;
+    env: Environment;
+}, given: {
+    value: Value | undefined;
+    env: Environment;
+}): boolean;

package/out/types/src/yo-cli.d.ts

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