@shd101wyy/yo 0.0.2

package/out/types/src/evaluator/builtins/arc_fns.d.ts

@@ -0,0 +1,58 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoDecrRc({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoIncrRc({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoIncrRcAtomic({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoDecrRcAtomic({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoRcOwn({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoDynVtableDrop({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoDynVtableDup({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoSomeTypeDrop({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoSomeTypeDup({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoIsoExtract({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateYoIsoDispose({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/builtins/as.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAs({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/async_fns.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAsync({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/compt_assert.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateComptAssert({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/compt_boolean_fns.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoComptBooleanFunctions({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/compt_expect_error.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateComptExpectError({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/compt_list_fns.d.ts

@@ -0,0 +1,33 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoComptListCar({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoComptListCdr({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoComptListCons({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoComptListAppend({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoComptListLength({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoComptListElementType({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/compt_print.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateComptPrint({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/compt_string_fns.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoComptStringFunctions({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/consume.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateConsume({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/drop.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateDrop({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/builtins/dup.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateDup({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/builtins/expr_fns.d.ts

@@ -0,0 +1,33 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoExprIsAtom({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoExprIsFnCall({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoExprGetCallee({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoExprGetArgs({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoExprToString({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoExprEq({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/future_fns.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAwait({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/gc.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoGcCollect({ expr, env, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/builtins/gensym.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateGensym({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/impl_constraint.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateImplConstraint({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/macro_expand.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateMacroExpand({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/numeric_fns.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoNumericFunctions({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/panic.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluatePanic({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/ptr_fns.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAddressCall({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/quote.d.ts

@@ -0,0 +1,13 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function processUnquotesInExpr({ expr, env, context, }: {
+    expr: Expr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
+export declare function evaluateQuote({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/rc.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateRc({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/sizeof.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateSizeOf({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/the.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateThe({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/type_fns.d.ts

@@ -0,0 +1,28 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoTypeToString({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoAreTypesCompatible({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoTypeContainsGcType({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoTypeCanFormGcCycle({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoTypeImpls({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/va_start.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateVaStart({ expr, env, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/var_fns.d.ts

@@ -0,0 +1,18 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateYoVarPrintInfo({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoVarIsOwningTheGcValue({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateYoVarHasOtherAliases({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/calls/array.d.ts

@@ -0,0 +1,13 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { ArrayType, SliceType } from "../../types";
+import { ArrayValue } from "../../value";
+import { ArrayCallResult, EvaluatorContext } from "../context";
+export declare function tryToCallArrayWithArguments({ expr, arrayType, arrayValue, argExprs, callerEnv, context, }: {
+    expr: FuncCallExpr;
+    arrayType: ArrayType | SliceType;
+    arrayValue: ArrayValue | undefined;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): ArrayCallResult;

package/out/types/src/evaluator/calls/array_type.d.ts

@@ -0,0 +1,11 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { ArrayType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function tryToImplementArrayByArrayType({ expr, arrayType, argExprs, callerEnv, context, }: {
+    expr: FuncCallExpr;
+    arrayType: ArrayType;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/calls/closure_type.d.ts

@@ -0,0 +1,11 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { DynType, FnModuleType, SomeType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function tryToImplementClosureByFnModuleType({ expr, fnModuleType, wrapperType, callerEnv, context, }: {
+    expr: FuncCallExpr;
+    fnModuleType: FnModuleType;
+    wrapperType: SomeType | DynType;
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/calls/compt_function.d.ts

@@ -0,0 +1,19 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { FunctionValue } from "../../function-value";
+import { FunctionType } from "../../types";
+import { Value } from "../../value";
+import { ArgValues, EvaluatorContext } from "../context";
+export declare function evaluateComptFunctionCall({ functionCalleeExpr, functionType, functionValue, argValues: argValues_, callerEnv, calleeEnv, context, }: {
+    functionCalleeExpr: Expr | undefined;
+    functionType: FunctionType;
+    functionValue: FunctionValue;
+    argValues: ArgValues;
+    callerEnv: Environment;
+    calleeEnv: Environment;
+    context: EvaluatorContext;
+}): {
+    value: Value;
+    callerEnv: Environment;
+    calleeEnv: Environment;
+};

package/out/types/src/evaluator/calls/compt_list_type.d.ts

@@ -0,0 +1,11 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { ComptListType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function tryToImplementComptListByComptListType({ expr, comptListType, argExprs, callerEnv, context, }: {
+    expr: FuncCallExpr;
+    comptListType: ComptListType;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/calls/function.d.ts

@@ -0,0 +1,16 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { FunctionValue } from "../../function-value";
+import { TypeValue } from "../../type-value";
+import { Type } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateFunctionCall({ expr, env, context, givenFunc, forMacroExpansion, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+    givenFunc?: {
+        type: Type;
+        value: TypeValue | FunctionValue | undefined;
+    };
+    forMacroExpansion?: boolean;
+}): Expr;

package/out/types/src/evaluator/calls/function_type.d.ts

@@ -0,0 +1,15 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { FunctionValue } from "../../function-value";
+import { FunctionType } from "../../types";
+import { EvaluatorContext, FunctionEvaluationContext } from "../context";
+export declare function createFunctionBodyEvaluationContext(context: EvaluatorContext, functionType: FunctionType, functionValue: FunctionValue, env: Environment): {
+    evaluationContext: EvaluatorContext;
+    functionBodyContext: FunctionEvaluationContext;
+};
+export declare function tryToImplementFunctionByFunctionType({ expr, functionType, callerEnv, context, }: {
+    expr: FuncCallExpr;
+    functionType: FunctionType;
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): Expr;

package/out/types/src/evaluator/calls/helper.d.ts

@@ -0,0 +1,42 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { FunctionValue } from "../../function-value";
+import { FunctionParameter, FunctionType, Type } from "../../types";
+import { Value } from "../../value";
+import { EvaluatorContext, FunctionCallResult } from "../context";
+export declare function checkIfFunctionParameterMatchesArgument({ functionType, parameter, argExprs, argIndex, calleeEnv, callerEnv, context, isMethodCall, runtimeArgExprsInOrder, }: {
+    functionType: FunctionType;
+    parameter: FunctionParameter;
+    argExprs: Expr[];
+    argIndex: number;
+    calleeEnv: Environment;
+    callerEnv: Environment;
+    context: EvaluatorContext;
+    isMethodCall: boolean;
+    runtimeArgExprsInOrder: Expr[];
+}): {
+    calleeEnv: Environment;
+    callerEnv: Environment;
+    context: EvaluatorContext;
+    argValue: Value | undefined;
+    argType: Type;
+    parameterType: Type;
+};
+export declare function extractFunctionValue(value: Value | undefined): FunctionValue | undefined;
+export declare function tryToCallFunctionWithArguments({ expr, functionValue, functionType, functionCalleeExpr, argExprs, callerEnv, context, isMethodCall, skipSpecialization, }: {
+    functionValue?: FunctionValue;
+    functionType: FunctionType;
+    expr?: Expr;
+    functionCalleeExpr?: Expr;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+    isMethodCall: boolean;
+    skipSpecialization?: boolean;
+}): FunctionCallResult;
+export declare function validateFunctionReturnType({ returnType, expr, env, context, }: {
+    returnType: Type;
+    expr: Expr | undefined;
+    env: Environment;
+    context: EvaluatorContext;
+}): void;

package/out/types/src/evaluator/calls/iso.d.ts

@@ -0,0 +1,15 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { IsoType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateIsoTypeCall({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateIsoValueCall({ expr, env, context, isoType, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+    isoType: IsoType;
+}): FuncCallExpr;

package/out/types/src/evaluator/calls/module_type.d.ts

@@ -0,0 +1,11 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { ModuleType } from "../../types";
+import { EvaluatorContext, ModuleTypeCallResult } from "../context";
+export declare function tryToImplementModuleWithArgumentsByModuleType({ moduleExpr, moduleType, argExprs, callerEnv, context, }: {
+    moduleExpr: Expr;
+    moduleType: ModuleType;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): ModuleTypeCallResult;

package/out/types/src/evaluator/calls/numeric_type.d.ts

@@ -0,0 +1,15 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { Type } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function isConvertibleNumericType(type: Type): boolean;
+export declare function tryToConvertToNumericType({ targetType, argExpr, expr, callerEnv, context, }: {
+    targetType: Type;
+    argExpr: Expr;
+    expr: FuncCallExpr;
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): {
+    expr: Expr;
+    env: Environment;
+} | undefined;

package/out/types/src/evaluator/calls/pointer.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateRawPointerCall({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/calls/pointer_type.d.ts

@@ -0,0 +1,14 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { Type } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function tryToConvertToPointerType({ targetType, argExpr, expr, callerEnv, context, }: {
+    targetType: Type;
+    argExpr: Expr;
+    expr: FuncCallExpr;
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): {
+    expr: Expr;
+    env: Environment;
+} | undefined;

package/out/types/src/evaluator/calls/type.d.ts

@@ -0,0 +1,12 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { TypeField } from "../../types";
+import { EvaluatorContext, TypeCallResult } from "../context";
+export declare function tryToCallTypeWithArguments({ typeFields, functionCalleeExpr, argExprs, callerEnv, context, isUnionType, }: {
+    typeFields: TypeField[];
+    functionCalleeExpr: Expr;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+    isUnionType?: boolean;
+}): TypeCallResult;