@shd101wyy/yo 0.0.2

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

@@ -0,0 +1,456 @@
+import { Environment, Frame, Variable } from "./env";
+import type { AwaitAnalysisResult } from "./evaluator/async/await-analysis-types";
+import { EvaluatorContext } from "./evaluator/context";
+import { Token } from "./token";
+import { StructType, Type } from "./types";
+import { ModuleValue, Value } from "./value";
+import { ValueTag } from "./value-tag";
+export type Path = string[];
+export type PathCollection = Path[];
+export declare function pathContainsPath(path1: Path, path2: Path): boolean;
+export declare function pathCollectionConflictsWithPathCollection(collection1: PathCollection, collection2: PathCollection): boolean;
+export declare function pathConflictsWithPath(path1: Path, path2: Path): boolean;
+export declare enum ExprTag {
+    Atom = "Atom",
+    FuncCall = "FuncCall"
+}
+export interface RuntimeDestructuring {
+    label: string;
+    type: Type;
+    variableName: string;
+}
+export type ControlFlowKind = "return" | "break" | "continue";
+export interface EvaluatedExprData {
+    env: Environment;
+    type: Type;
+    value?: Value;
+    convertedRuntimeType?: Type;
+    variableName?: string;
+    originType?: Type;
+    isAccessingProperty?: boolean;
+    pathCollection: PathCollection;
+    runtimeArgExprsInOrder?: Expr[];
+    runtimeDestructurings?: RuntimeDestructuring[];
+    controlFlow?: ControlFlowKind;
+    dynCallModuleValues?: ModuleValue[];
+    caseExecuted?: boolean;
+    comment?: string;
+    deferredDupExpressions?: Expr[];
+    deferredDropExpressions?: Expr[];
+    asyncStackSize?: Expr;
+    asyncStateMachineStructName?: string;
+    captureType?: StructType;
+    awaitAnalysis?: AwaitAnalysisResult;
+    closureFunctionValue?: Value & {
+        tag: ValueTag.Function;
+    };
+    macroExpansion?: Expr;
+    poppedEnvFrame?: Frame;
+    originalExpr?: Expr;
+}
+export type AtomExpr = {
+    tag: ExprTag.Atom;
+    token: Token;
+    $?: EvaluatedExprData | undefined;
+};
+export type FuncCallExpr = {
+    tag: ExprTag.FuncCall;
+    func: Expr;
+    args: Expr[];
+    isInfix?: boolean;
+    token: Token;
+    $?: EvaluatedExprData | undefined;
+};
+export declare function cloneExpr(expr: Expr): Expr;
+export type Expr = AtomExpr | FuncCallExpr;
+export declare function exprIsFunctionCall(expr: Expr | undefined): expr is FuncCallExpr;
+export declare function exprIsAtom(expr: Expr | undefined): expr is AtomExpr;
+export declare function exprIsAtomOf(expr: Expr, values: string | string[]): boolean;
+export declare function exprIsAtomAndOperator(expr: Expr): boolean;
+export declare function exprIsFunctionCallOf(expr: Expr, funcNames: string | string[], argumentCount?: number): boolean;
+export declare function expectExprToBeFunctionCallOf(expr: Expr, expectedFunctionName: string | string[], expectedArgCount?: number): void;
+export declare function expectExprToHaveBeenEvaluated(expr: Expr, errorMessage?: string): EvaluatedExprData;
+export declare function exprsAreEqual(expr1: Expr, expr2: Expr): boolean;
+export declare const BuiltinKeywords: {
+    compt: string[];
+    ref: string[];
+    forall: string[];
+    where: string[];
+    quote: string[];
+    unquote: string[];
+    unquote_splicing: string[];
+    return: string[];
+    recur: string[];
+    fn: string[];
+    unsafe_fn: string[];
+    extern: string[];
+    cond: string[];
+    type: string[];
+    match: string[];
+    test: string[];
+    struct: string[];
+    object: string[];
+    newtype: string[];
+    enum: string[];
+    union: string[];
+    module: string[];
+    impl: string[];
+    Impl: string[];
+    begin: string[];
+    module_begin: string[];
+    import: string[];
+    export: string[];
+    open: string[];
+    clone: string[];
+    break: string[];
+    continue: string[];
+    while: string[];
+    if: string[];
+    op_and: string[];
+    op_or: string[];
+    not: string[];
+    gensym: string[];
+    dyn: string[];
+    Dyn: string[];
+    Fn: string[];
+    c_include: string[];
+    undefined: string[];
+    null: string[];
+    true: string[];
+    false: string[];
+    unique: string[];
+    Ptr: string[];
+    Iso: string[];
+    Tuple: string[];
+    Array: string[];
+    Slice: string[];
+    Future: string[];
+    Concrete: string[];
+    Type: string[];
+    Module: string[];
+    ComptList: string[];
+    tuple: string;
+    array: string;
+    compt_list: string;
+};
+export declare const BuiltinFunctions: {
+    compt_expect_error: string[];
+    compt_assert: string[];
+    compt_print: string[];
+    va_start: string[];
+    typeof: string[];
+    sizeof: string[];
+    alignof: string[];
+    consume: string[];
+    macro_expand: string[];
+    as: string[];
+    the: string[];
+    do: string[];
+    rc: string;
+    async: string[];
+    await: string[];
+    __yo_thread_set_maximum_threads: string[];
+    __yo_ptr_add: string[];
+    __yo_ptr_sub: string[];
+    __yo_ptr_diff: string[];
+    __yo_ptr_eq: string[];
+    __yo_ptr_neq: string[];
+    __yo_ptr_lt: string[];
+    __yo_ptr_lte: string[];
+    __yo_ptr_gt: string[];
+    __yo_ptr_gte: string[];
+    __yo_address_of: string[];
+    __yo_ptr_deref: string[];
+    __yo_ptr_set: string[];
+    __yo_slice_len: string[];
+    __yo_as: string[];
+    __yo_expr_is_atom: string[];
+    __yo_expr_is_fn_call: string[];
+    __yo_expr_get_callee: string[];
+    __yo_expr_get_args: string[];
+    __yo_expr_to_string: string[];
+    __yo_expr_eq: string[];
+    __yo_compt_list_car: string[];
+    __yo_compt_list_cdr: string[];
+    __yo_compt_list_cons: string[];
+    __yo_compt_list_append: string[];
+    __yo_compt_list_length: string[];
+    __yo_compt_list_element_type: string[];
+    __yo_compt_int_add: string[];
+    __yo_compt_int_sub: string[];
+    __yo_compt_int_mul: string[];
+    __yo_compt_int_div: string[];
+    __yo_compt_int_mod: string[];
+    __yo_compt_int_eq: string[];
+    __yo_compt_int_neq: string[];
+    __yo_compt_int_lt: string[];
+    __yo_compt_int_lte: string[];
+    __yo_compt_int_gt: string[];
+    __yo_compt_int_gte: string[];
+    __yo_compt_int_as: string[];
+    __yo_compt_int_neg: string[];
+    __yo_compt_int_to_float: string[];
+    __yo_compt_int_to_string: string[];
+    __yo_compt_float_add: string[];
+    __yo_compt_float_sub: string[];
+    __yo_compt_float_mul: string[];
+    __yo_compt_float_div: string[];
+    __yo_compt_float_eq: string[];
+    __yo_compt_float_neq: string[];
+    __yo_compt_float_lt: string[];
+    __yo_compt_float_lte: string[];
+    __yo_compt_float_gt: string[];
+    __yo_compt_float_gte: string[];
+    __yo_compt_float_as: string[];
+    __yo_compt_float_neg: string[];
+    __yo_compt_float_to_int: string[];
+    __yo_compt_float_to_string: string[];
+    __yo_u8_add: string[];
+    __yo_u8_sub: string[];
+    __yo_u8_mul: string[];
+    __yo_u8_div: string[];
+    __yo_u8_mod: string[];
+    __yo_u8_eq: string[];
+    __yo_u8_neq: string[];
+    __yo_u8_lt: string[];
+    __yo_u8_lte: string[];
+    __yo_u8_gt: string[];
+    __yo_u8_gte: string[];
+    __yo_u8_neg: string[];
+    __yo_u8_to_string: string[];
+    __yo_u8_as: string[];
+    __yo_i8_add: string[];
+    __yo_i8_sub: string[];
+    __yo_i8_mul: string[];
+    __yo_i8_div: string[];
+    __yo_i8_mod: string[];
+    __yo_i8_eq: string[];
+    __yo_i8_neq: string[];
+    __yo_i8_lt: string[];
+    __yo_i8_lte: string[];
+    __yo_i8_gt: string[];
+    __yo_i8_gte: string[];
+    __yo_i8_neg: string[];
+    __yo_i8_to_string: string[];
+    __yo_i8_as: string[];
+    __yo_u16_add: string[];
+    __yo_u16_sub: string[];
+    __yo_u16_mul: string[];
+    __yo_u16_div: string[];
+    __yo_u16_mod: string[];
+    __yo_u16_eq: string[];
+    __yo_u16_neq: string[];
+    __yo_u16_lt: string[];
+    __yo_u16_lte: string[];
+    __yo_u16_gt: string[];
+    __yo_u16_gte: string[];
+    __yo_u16_neg: string[];
+    __yo_u16_to_string: string[];
+    __yo_u16_as: string[];
+    __yo_i16_add: string[];
+    __yo_i16_sub: string[];
+    __yo_i16_mul: string[];
+    __yo_i16_div: string[];
+    __yo_i16_mod: string[];
+    __yo_i16_eq: string[];
+    __yo_i16_neq: string[];
+    __yo_i16_lt: string[];
+    __yo_i16_lte: string[];
+    __yo_i16_gt: string[];
+    __yo_i16_gte: string[];
+    __yo_i16_neg: string[];
+    __yo_i16_to_string: string[];
+    __yo_i16_as: string[];
+    __yo_u32_add: string[];
+    __yo_u32_sub: string[];
+    __yo_u32_mul: string[];
+    __yo_u32_div: string[];
+    __yo_u32_mod: string[];
+    __yo_u32_eq: string[];
+    __yo_u32_neq: string[];
+    __yo_u32_lt: string[];
+    __yo_u32_lte: string[];
+    __yo_u32_gt: string[];
+    __yo_u32_gte: string[];
+    __yo_u32_neg: string[];
+    __yo_u32_to_string: string[];
+    __yo_u32_as: string[];
+    __yo_i32_add: string[];
+    __yo_i32_sub: string[];
+    __yo_i32_mul: string[];
+    __yo_i32_div: string[];
+    __yo_i32_mod: string[];
+    __yo_i32_eq: string[];
+    __yo_i32_neq: string[];
+    __yo_i32_lt: string[];
+    __yo_i32_lte: string[];
+    __yo_i32_gt: string[];
+    __yo_i32_gte: string[];
+    __yo_i32_neg: string[];
+    __yo_i32_to_string: string[];
+    __yo_i32_as: string[];
+    __yo_u64_add: string[];
+    __yo_u64_sub: string[];
+    __yo_u64_mul: string[];
+    __yo_u64_div: string[];
+    __yo_u64_mod: string[];
+    __yo_u64_eq: string[];
+    __yo_u64_neq: string[];
+    __yo_u64_lt: string[];
+    __yo_u64_lte: string[];
+    __yo_u64_gt: string[];
+    __yo_u64_gte: string[];
+    __yo_u64_neg: string[];
+    __yo_u64_to_string: string[];
+    __yo_u64_as: string[];
+    __yo_i64_add: string[];
+    __yo_i64_sub: string[];
+    __yo_i64_mul: string[];
+    __yo_i64_div: string[];
+    __yo_i64_mod: string[];
+    __yo_i64_eq: string[];
+    __yo_i64_neq: string[];
+    __yo_i64_lt: string[];
+    __yo_i64_lte: string[];
+    __yo_i64_gt: string[];
+    __yo_i64_gte: string[];
+    __yo_i64_neg: string[];
+    __yo_i64_to_string: string[];
+    __yo_i64_as: string[];
+    __yo_usize_add: string[];
+    __yo_usize_sub: string[];
+    __yo_usize_mul: string[];
+    __yo_usize_div: string[];
+    __yo_usize_mod: string[];
+    __yo_usize_eq: string[];
+    __yo_usize_neq: string[];
+    __yo_usize_lt: string[];
+    __yo_usize_lte: string[];
+    __yo_usize_gt: string[];
+    __yo_usize_gte: string[];
+    __yo_usize_neg: string[];
+    __yo_usize_to_string: string[];
+    __yo_usize_as: string[];
+    __yo_isize_add: string[];
+    __yo_isize_sub: string[];
+    __yo_isize_mul: string[];
+    __yo_isize_div: string[];
+    __yo_isize_mod: string[];
+    __yo_isize_eq: string[];
+    __yo_isize_neq: string[];
+    __yo_isize_lt: string[];
+    __yo_isize_lte: string[];
+    __yo_isize_gt: string[];
+    __yo_isize_gte: string[];
+    __yo_isize_neg: string[];
+    __yo_isize_to_string: string[];
+    __yo_isize_as: string[];
+    __yo_f32_add: string[];
+    __yo_f32_sub: string[];
+    __yo_f32_mul: string[];
+    __yo_f32_div: string[];
+    __yo_f32_eq: string[];
+    __yo_f32_neq: string[];
+    __yo_f32_lt: string[];
+    __yo_f32_lte: string[];
+    __yo_f32_gt: string[];
+    __yo_f32_gte: string[];
+    __yo_f32_neg: string[];
+    __yo_f32_to_string: string[];
+    __yo_f32_as: string[];
+    __yo_f64_add: string[];
+    __yo_f64_sub: string[];
+    __yo_f64_mul: string[];
+    __yo_f64_div: string[];
+    __yo_f64_eq: string[];
+    __yo_f64_neq: string[];
+    __yo_f64_lt: string[];
+    __yo_f64_lte: string[];
+    __yo_f64_gt: string[];
+    __yo_f64_gte: string[];
+    __yo_f64_neg: string[];
+    __yo_f64_to_string: string[];
+    __yo_f64_as: string[];
+    __yo_compt_boolean_and: string[];
+    __yo_compt_boolean_or: string[];
+    __yo_compt_boolean_eq: string[];
+    __yo_compt_boolean_neq: string[];
+    __yo_compt_boolean_not: string[];
+    __yo_compt_boolean_to_string: string[];
+    __yo_compt_string_concat: string[];
+    __yo_compt_string_eq: string[];
+    __yo_compt_string_neq: string[];
+    __yo_compt_string_lt: string[];
+    __yo_compt_string_lte: string[];
+    __yo_compt_string_gt: string[];
+    __yo_compt_string_gte: string[];
+    __yo_compt_string_length: string[];
+    __yo_compt_string_to_upper: string[];
+    __yo_compt_string_to_lower: string[];
+    __yo_compt_string_slice: string[];
+    __yo_type_to_string: string[];
+    __yo_type_contains_gc_type: string[];
+    __yo_type_can_form_gc_cycle: string[];
+    __yo_are_types_compatible: string[];
+    __yo_type_impls: string[];
+    __yo_var_print_info: string[];
+    __yo_var_is_owning_the_gc_value: string[];
+    __yo_var_has_other_aliases: string[];
+    __yo_op_add: string[];
+    __yo_op_sub: string[];
+    __yo_op_mul: string[];
+    __yo_op_div: string[];
+    __yo_op_mod: string[];
+    __yo_op_neg: string[];
+    __yo_op_eq: string[];
+    __yo_op_neq: string[];
+    __yo_op_lt: string[];
+    __yo_op_lte: string[];
+    __yo_op_gt: string[];
+    __yo_op_gte: string[];
+    __yo_op_not: string[];
+    __yo_op_bit_and: string[];
+    __yo_op_bit_or: string[];
+    __yo_op_bit_xor: string[];
+    __yo_op_bit_complement: string[];
+    __yo_op_bit_left_shift: string[];
+    __yo_op_bit_right_shift: string[];
+    c_include: string[];
+    panic: string[];
+    __yo_decr_rc: string[];
+    __yo_incr_rc: string[];
+    __yo_decr_rc_atomic: string[];
+    __yo_incr_rc_atomic: string[];
+    __yo_rc_own: string[];
+    __yo_iso_extract: string[];
+    __yo_iso_dispose: string[];
+    __yo_gc_collect: string[];
+    __yo_dyn_drop: string[];
+    __yo_dyn_dup: string[];
+    __yo_sometype_drop: string[];
+    __yo_sometype_dup: string[];
+    ___drop: string[];
+    ___dispose: string[];
+    ___dup: string[];
+    dispose: string[];
+    __yo_noop: string[];
+    __yo_return_self: string[];
+    __yo_ms_sleep: string[];
+};
+export declare function exprIsInfixOperatorFunctionCall(expr: Expr): boolean;
+export interface ExprToStringConfig {
+    prettyPrint?: boolean;
+    indentSize?: number;
+    maxLineLength?: number;
+    indentLevel?: number;
+}
+export declare function exprToString(expr: Expr, config?: ExprToStringConfig): string;
+export declare function attachTempVariableToExpr(expr: Expr, isOwningTheGcValue: boolean, isOwningTheSameGcValueAs?: Variable): void;
+export declare function mergeAndCheckEnvs(env: Environment, bodies: Expr[]): Environment;
+export declare function replaceFuncCallExprWithFuncCallExpr(funcExpr: FuncCallExpr, newFuncExpr: FuncCallExpr): void;
+export declare function replaceFuncCallExprWithAtomExpr(funcExpr: FuncCallExpr, newAtomExpr: AtomExpr): void;
+export declare function replaceExprWithFuncCallExpr(expr: Expr, newFuncExpr: FuncCallExpr): void;
+export declare function replaceExprWithAtomExpr(expr: Expr, newAtomExpr: AtomExpr): void;
+export declare function setExprAsConsumed(expr: Expr, env: Environment, allowConsumeAgain?: boolean): Environment;
+export declare function setExprAsNeedsToCallDup(expr: Expr, context: EvaluatorContext): void;
+export declare function requireExprNotConsumed(expr: Expr, env: Environment): void;

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

@@ -0,0 +1,42 @@
+import { Environment } from "./env";
+import { CapturedVariableInfo } from "./evaluator/context";
+import { Expr } from "./expr";
+import { FnModuleType, FunctionType, Type } from "./types";
+import type { Value } from "./value";
+import { ValueTag } from "./value-tag";
+export type FuncValueId = string;
+export interface CalledComptFunctionCache {
+    funcId: FuncValueId;
+    argValues: Value[];
+    env: Environment;
+    value: Value;
+    body: Expr;
+}
+export interface SpecializedFunctionCache {
+    funcId: FuncValueId;
+    env: Environment;
+    compileTimeArgValues: Value[];
+    runtimeParameterTypes: Type[];
+    specializedFunction: FunctionValue;
+}
+export type FunctionValue = {
+    tag: ValueTag.Function;
+    type: FunctionType;
+    specializedType?: FunctionType;
+    frameLevel: number;
+    body: Expr;
+    cpsTransformedBody?: Expr;
+    funcName?: string;
+    funcId: FuncValueId;
+    calledComptFunctionCaches: CalledComptFunctionCache[];
+    specializedFunctionCaches: SpecializedFunctionCache[];
+    closureInfo?: ClosureInfo;
+};
+export interface FunctionCapturedVariableInfo extends CapturedVariableInfo {
+    value: Value | undefined;
+    type: Type;
+}
+export interface ClosureInfo {
+    closureType: FnModuleType;
+    captureType: Type | undefined;
+}

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

@@ -0,0 +1,4 @@
+export * from "./evaluator";
+export * from "./lexer";
+export * from "./parser";
+export * from "./token";

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

@@ -0,0 +1,2 @@
+import { Token } from "./token";
+export declare function tokenize(input: string, modulePath: string): Token[];

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

@@ -0,0 +1 @@
+export declare function debug(...args: unknown[]): void;

package/out/types/src/module-manager.d.ts

@@ -0,0 +1,30 @@
+import Evaluator from "./evaluator/index";
+import { ModuleValue } from "./value";
+export declare class ModuleManager {
+    modules: Map<string, {
+        moduleValue: ModuleValue;
+        moduleError: Error | undefined;
+        evaluator: Evaluator;
+    }>;
+    private dependencies;
+    private dependents;
+    stdPath: string;
+    private codeGenratorC;
+    constructor();
+    private addDependency;
+    private getDependentModules;
+    private clearDependencies;
+    loadModule(modulePath: string, inputString?: string, parentModule?: string): {
+        moduleValue: ModuleValue;
+        moduleError: Error | undefined;
+    };
+    deleteModule(modulePath: string): void;
+    compileModule(modulePath: string, { emitC, debugGc, debugParallelism, debugAsyncAwait, allocator, }?: {
+        emitC?: boolean;
+        debugGc?: boolean;
+        debugParallelism?: boolean;
+        debugAsyncAwait?: boolean;
+        allocator?: "mimalloc" | "libc";
+    }): void;
+    getGeneratedCode(): string;
+}

package/out/types/src/naming-checker.d.ts

@@ -0,0 +1,4 @@
+export declare function isUpperCamelCase(name: string): boolean;
+export declare function isLowerCamelCase(name: string): boolean;
+export declare function isSnakeCase(name: string): boolean;
+export declare function isScreamingSnakeCase(name: string): boolean;

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

@@ -0,0 +1,33 @@
+import { Expr } from "./expr";
+import { Token } from "./token";
+export default class Parser {
+    private inputString;
+    private modulePath;
+    private tokens;
+    private program;
+    private parserError;
+    constructor({ modulePath, inputString, }: {
+        modulePath: string;
+        inputString: string;
+    });
+    private skipWhitespace;
+    private skipWhitespaceBackward;
+    private isParenthesizedExpression;
+    private parseParenExpr;
+    private parseArrayExpr;
+    private parseCurlyBracketExpr;
+    private parsePrimary;
+    private isOperatorAtLineStart;
+    private parseLeftAssociativeOperator;
+    private getExprMinimumColumnNumber;
+    private parsePrimaryEnd;
+    private parseFunctionArguments;
+    private parseFunctionCall;
+    private parseExpression;
+    programToString(): string;
+    private parse;
+    getProgram(): Expr[];
+    getParserError(): Error | undefined;
+    getTokens(): Token[];
+}
+export declare function generateExprFromCode(code: string): Expr;

package/out/types/src/test-runner.d.ts

@@ -0,0 +1,30 @@
+import { Expr } from "./expr";
+export interface TestDeclaration {
+    name: string;
+    bodyExpr: Expr;
+    filePath: string;
+    lineNumber: number;
+}
+export interface TestResult {
+    testName: string;
+    filePath: string;
+    passed: boolean;
+    errorMessage?: string;
+    duration: number;
+}
+export interface TestRunSummary {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    results: TestResult[];
+    duration: number;
+}
+export declare function findTestFiles(targetPath: string): string[];
+export declare function extractTests(filePath: string): TestDeclaration[];
+export declare function runTests(testFiles: string[], options?: {
+    cCompiler?: string;
+    verbose?: boolean;
+    bail?: boolean;
+    testNamePattern?: string;
+    parallel?: number;
+}): Promise<TestRunSummary>;

package/out/types/src/tests/codegen.test.d.ts

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

package/out/types/src/tests/fixme.test.d.ts

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

package/out/types/src/tests/module-manager.test.d.ts

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

package/out/types/src/tests/parser.test.d.ts

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

package/out/types/src/tests/std.test.d.ts

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

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

@@ -0,0 +1,40 @@
+export declare enum TokenType {
+    Operator = "operator",
+    Dot = ".",
+    LParen = "(",
+    RParen = ")",
+    LBracket = "[",
+    RBracket = "]",
+    LCurlyBracket = "{",
+    RCurlyBracket = "}",
+    Char = "char",
+    String = "string",
+    Identifier = "identifier",
+    Integer = "integer",
+    Float = "float",
+    Bool = "bool",
+    Semicolon = ";",
+    Comma = ",",
+    SingleLineComment = "single_line_comment",
+    MultiLineComment = "multi_line_comment",
+    Whitespace = "whitespace",
+    BacktickIdentifier = "backtick_identifier"
+}
+export interface Token {
+    modulePath: string;
+    inputString: string;
+    type: TokenType;
+    value: string;
+    position: {
+        row: number;
+        column: number;
+        character: number;
+    };
+}
+export declare const PlaceholderToken: Token;
+export declare const RAIIToken: Token;
+export declare const Operators: string[];
+export declare function charIsOperator(char: string): boolean;
+export declare function stringIsOperator(str: string): boolean;
+export declare const IdentifierRegex: RegExp;
+export declare function findMatchingBracketTokenIndex(tokens: Token[], index: number): number;

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

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

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

@@ -0,0 +1,16 @@
+import { Environment } from "../env";
+import { FunctionType, Type } from "./definitions";
+export declare function areTypesCompatible(expected: {
+    type: Type;
+    env: Environment;
+}, given: {
+    type: Type;
+    env: Environment;
+}, requireExactMatch?: boolean, visitedPairs?: Set<string>): boolean;
+export declare function areFunctionTypesCompatible(expected: {
+    type: FunctionType;
+    env: Environment;
+}, given: {
+    type: FunctionType;
+    env: Environment;
+}, requireExactMatch?: boolean): boolean;