@shd101wyy/yo 0.1.3 → 0.1.5

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

@@ -1,6 +1,6 @@
 import type { EvaluatorContext } from "./evaluator/context";
 import type { Token } from "./token";
-import type { SomeType, TraitType, Type } from "./types/definitions";
+import type { SomeType, TraitType, Type, TypeApplicationType } from "./types/definitions";
 import { type Value } from "./value";
 export interface Variable {
     id: string;
@@ -54,6 +54,16 @@ export declare function getWhereClauseConstraintsForSomeType(env: Environment, s
     requiredTraits: TraitType[];
     negativeTraits: TraitType[];
 } | undefined;
+export declare function addWhereClauseConstraintForTypeApplication({ env, typeApp, traitType, isNegated, }: {
+    env: Environment;
+    typeApp: TypeApplicationType;
+    traitType: TraitType;
+    isNegated: boolean;
+}): Environment;
+export declare function getWhereClauseConstraintsForTypeApplication(env: Environment, typeApp: TypeApplicationType): {
+    requiredTraits: TraitType[];
+    negativeTraits: TraitType[];
+} | undefined;
 export declare function setEnvContainingPrelude(env: Environment): void;
 export declare function clearEnvContainingPrelude(): void;
 export declare function createEnvContainingPrelude(): Environment;

package/out/types/src/evaluator/types/enum.d.ts

@@ -1,4 +1,4 @@
-import type { Environment } from "../../env";
+import { type Environment } from "../../env";
 import { type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
 export declare function evaluateEnumType({ expr, env, context, }: {

package/out/types/src/evaluator/types/synthesizer.d.ts

@@ -1,6 +1,11 @@
 import { type Environment } from "../../env";
+import { type Token } from "../../token";
 import type { Type } from "../../types/definitions";
 export declare function canAssignTypeHierarchy(expected: Type, given: Type): boolean;
+export interface SynthesizeTypesOptions {
+    setResolvedConcreteType?: boolean;
+    token?: Token;
+}
 export declare function synthesizeTypes(expected: {
     type: Type;
     env: Environment;
@@ -10,7 +15,7 @@ export declare function synthesizeTypes(expected: {
 }, checkedTypePairs?: {
     expected: Type;
     given: Type;
-}[]): {
+}[], options?: SynthesizeTypesOptions): {
     expectedEnv: Environment;
     givenEnv: Environment;
 };

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

@@ -13,4 +13,4 @@ export declare function areFunctionTypesCompatible(expected: {
 }, given: {
     type: FunctionType;
     env: Environment;
-}, requireExactMatch?: boolean): boolean;
+}, requireExactMatch?: boolean, visitedPairs?: Set<string>): boolean;

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

@@ -3,7 +3,7 @@ import type { EvaluatorContext } from "../evaluator/context";
 import type { Expr } from "../expr";
 import type { FunctionValue } from "../function-value";
 import { type Value } from "../value";
-import type { ArcType, ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArcType, ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function createComptimeIntType(): Type;
 export declare function createComptimeFloatType(): Type;
 export declare function createComptimeStringType(): Type;
@@ -90,4 +90,5 @@ export declare function createDynType({ requiredTraits, env, negativeTraits, }:
     env: Environment;
     negativeTraits?: TraitType[];
 }): DynType;
+export declare function createTypeApplicationType(constructor: SomeType, args: Type[], resultKind: Type, env: Environment): TypeApplicationType;
 export declare function clearAllCachedTypes(): void;

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

@@ -54,12 +54,20 @@ export interface SomeType extends Type {
         argValues: Value[];
     };
     isEffectsRow?: boolean;
+    kindFunctionType?: FunctionType;
 }
 export interface EffectsRowType extends Type {
     tag: TypeTag.EffectsRow;
     implicitParameters: FunctionImplicitParameter[];
     trait: TraitType;
 }
+export interface TypeApplicationType extends Type {
+    tag: TypeTag.TypeApplication;
+    constructor: SomeType;
+    args: Type[];
+    resultKind: Type;
+    trait: TraitType;
+}
 export interface ArrayType extends Type {
     tag: TypeTag.Array;
     childType: Type;
@@ -194,6 +202,7 @@ export interface EnumVariant {
     name: string;
     fields?: TypeField[];
     discriminant?: bigint;
+    gadtReturnTypeArgs?: Type[];
 }
 export interface EnumType extends Type {
     tag: TypeTag.Enum;
@@ -203,6 +212,8 @@ export interface EnumType extends Type {
     env: Environment;
     selectedVariantName?: string;
     requiredVariantNames?: string[];
+    typeConstructorArgs?: Type[];
+    isGadt?: boolean;
 }
 export interface UnionType extends Type {
     tag: TypeTag.Union;

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

@@ -1,5 +1,5 @@
 import { FunctionValue } from "../function-value";
-import type { ArcType, ArrayType, ComptimeListType, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArcType, ArrayType, ComptimeListType, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function isPrimitiveType(type: Type): boolean;
 export declare function isUnitType(type?: Type): boolean;
 export declare function isComptimeIntType(type?: Type): boolean;
@@ -47,6 +47,7 @@ export declare function isPtrType(type?: Type): type is PtrType;
 export declare function isIsoType(type?: Type): type is IsoType;
 export declare function isArcType(type?: Type): type is ArcType;
 export declare function isDynType(type?: Type): type is DynType;
+export declare function isTypeApplicationType(type?: Type): type is TypeApplicationType;
 export declare function isRcType(type?: Type): boolean;
 export declare function isIntegerType(type?: Type): boolean;
 export declare function isFloatType(type?: Type): boolean;

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

@@ -44,5 +44,6 @@ export declare enum TypeTag {
     Dyn = "Dyn",
     Expr = "Expr",
     ComptimeList = "ComptimeList",
-    EffectsRow = "EffectsRow"
+    EffectsRow = "EffectsRow",
+    TypeApplication = "TypeApplication"
 }