yukigo-ast 0.1.0

package/dist/globals/generics.d.ts

@@ -0,0 +1,740 @@
+import { Application, CompositionExpression, Lambda, Yield } from "../paradigms/functional.js";
+import { EntryPoint, Enumeration, ForLoop, Procedure, Repeat, Structure, While } from "../paradigms/imperative.js";
+import { Call, Clause, Exist, Findall, Forall, Not, RuntimePredicate } from "../paradigms/logic.js";
+import { Attribute, Class, Implement, Include, Interface, Method, New, Object, Self, Send, Super } from "../paradigms/object.js";
+import { Visitor } from "../visitor.js";
+import { Operation } from "./operators.js";
+import { Pattern } from "./patterns.js";
+import { LazyList, RuntimeFunction } from "./runtime.js";
+import { Type, TypeAlias, TypeCast, TypeSignature } from "./types.js";
+export type Modify<T, R> = Omit<T, keyof R> & R;
+type Metadata = Map<string, any>;
+/**
+ * @hidden
+ */
+export declare abstract class ASTNode {
+    /** @hidden */
+    loc: SourceLocation;
+    /** @hidden */
+    metadata: Metadata;
+    constructor(loc?: SourceLocation, metadata?: Metadata);
+    setMetadata(key: string, value: any): void;
+    getMetadata<T>(key: string): T | undefined;
+    hasMetadata(key: string): boolean;
+    /** @hidden */
+    abstract accept<R>(visitor: Visitor<R>): R;
+    /** @hidden */
+    abstract toJSON(): object;
+}
+/**
+ * Generic number primitive
+ * @category Literals
+ */
+export declare class NumberPrimitive extends ASTNode {
+    /** @hidden */
+    value: number;
+    constructor(value: number, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: number;
+    };
+}
+/**
+ * Generic boolean primitive
+ * @category Literals
+ */
+export declare class BooleanPrimitive extends ASTNode {
+    /** @hidden */
+    value: boolean;
+    constructor(value: boolean, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: boolean;
+    };
+}
+/**
+ * Represent lists - generic uniform variable-size collection of elements. Lists typically map to arrays, lists or sequence-like structures.
+ * @category Literals
+ */
+export declare class ListPrimitive extends ASTNode {
+    /** @hidden */
+    elements: Expression[];
+    constructor(elements: Expression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: Expression[];
+    };
+}
+/**
+ * Generic char primitive
+ * @category Literals
+ */
+export declare class CharPrimitive extends ASTNode {
+    /** @hidden */
+    value: string;
+    constructor(value: string, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: string;
+    };
+}
+/**
+ * Generic string primitive
+ * @category Literals
+ */
+export declare class StringPrimitive extends ASTNode {
+    /** @hidden */
+    value: string;
+    constructor(value: string, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: string;
+    };
+}
+/**
+ * Generic null/undefined primitive
+ * @category Literals
+ */
+export declare class NilPrimitive extends ASTNode {
+    /** @hidden */
+    value: undefined | null;
+    constructor(value: undefined | null, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: null;
+    };
+}
+/**
+ * Generic symbol primitive
+ * @category Literals
+ */
+export declare class SymbolPrimitive extends ASTNode {
+    /** @hidden */
+    value: string;
+    constructor(value: string, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    /**
+     * Compares the primitive to other Primitive passed by argument
+     * @param other Another Primitive to compare to.
+     * @returns True if both primitive have the same value
+     */
+    equals(other: Primitive): boolean;
+    toJSON(): {
+        type: string;
+        value: string;
+    };
+}
+export type YukigoPrimitive = "YuNumber" | "YuString" | "YuChar" | "YuBoolean" | "YuTuple" | "YuList" | "YuNil" | "YuDict" | "YuObject" | "YuSymbol";
+export type LogicResult = {
+    success: boolean;
+    solutions: Map<string, string>;
+};
+export type PrimitiveValue = number | boolean | string | RuntimeFunction | RuntimePredicate | LogicResult | LazyList | null | void | PrimitiveValue[] | undefined;
+export type Primitive = NumberPrimitive | BooleanPrimitive | CharPrimitive | StringPrimitive | NilPrimitive | SymbolPrimitive | ListPrimitive;
+/**
+ * Source location information
+ */
+export declare class SourceLocation {
+    line: number;
+    column: number;
+    constructor(line: number, column: number);
+    toJSON(): {
+        type: string;
+        line: number;
+        column: number;
+    };
+}
+/**
+ * Represent tuples - generic non-uniform fixed-size collection of elements
+ *
+ * @example
+ * (1, "Hello", true)
+ * @category Expressions
+ */
+export declare class TupleExpression extends ASTNode {
+    /** @hidden */
+    elements: Expression[];
+    constructor(elements: Expression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Fields of a data expression representations
+ * @category Expressions
+ */
+export declare class FieldExpression extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Data expression, used to construct Records
+ * @example
+ * f = DataName { fieldName = 2 }
+ * @category Expressions
+ */
+export declare class DataExpression extends ASTNode {
+    /** @hidden */
+    contents: FieldExpression[];
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, contents: FieldExpression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Cons expression, represent a concatenation of a head and a tail
+ * @example
+ * f = x : xs
+ * @category Expressions
+ */
+export declare class ConsExpression extends ASTNode {
+    /** @hidden */
+    tail: Expression;
+    /** @hidden */
+    head: Expression;
+    constructor(head: Expression, tail: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represent let...in expressions normally used in Haskell
+ * @example
+ * f = let x = 2 in x * 4
+ * @category Expressions
+ */
+export declare class LetInExpression extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    declarations: Sequence;
+    constructor(declarations: Sequence, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        declarations: any;
+        expression: any;
+    };
+}
+/**
+ * Otherwise used as the default case in GuardBody
+ * @example
+ * f x
+ *  | x == 2 = 16
+ *  | otherwise = x * 8
+ * @category Declarations
+ */
+export declare class Otherwise extends ASTNode {
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+    };
+}
+/**
+ * ListComprehension when the for expression is a yield.
+ * Scala's for comprehensions, Erlang's and Haskell's list comprehensions
+ * @example
+ * m = [ f x | x <- [1, 2, 3, 4] ]
+ * @category Expressions
+ */
+export declare class ListComprehension extends ASTNode {
+    /** @hidden */
+    generators: (Generator | Expression)[];
+    /** @hidden */
+    projection: Expression;
+    constructor(projection: Expression, generators: (Generator | Expression)[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Generator represents patterns like "Just m <- ms" or "x <- [1,2,3]"
+ * @example
+ * x <- [1, 2, 3, 4]
+ * @category Declarations
+ */
+export declare class Generator extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    variable: SymbolPrimitive;
+    constructor(variable: SymbolPrimitive, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * RangeExpression represents when a list is given by comprehension in a defined range
+ * @example
+ * (1..10)
+ * @example
+ * (1, 2..10)
+ * @example
+ * (1..)
+ * @category Expressions
+ */
+export declare class RangeExpression extends ASTNode {
+    /** @hidden */
+    step?: Expression;
+    /** @hidden */
+    end?: Expression;
+    /** @hidden */
+    start: Expression;
+    constructor(start: Expression, end?: Expression, // undefined for infinite ranges like [0..]
+    step?: Expression, // for [start, second .. end] syntax
+    loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+export type Expression = Primitive | Operation | TupleExpression | Print | Otherwise | ConsExpression | Self | Sequence | New | Include | Implement | DataExpression | CompositionExpression | Lambda | For | Application | Exist | Forall | Findall | Not | TypeCast | ListComprehension | RangeExpression;
+/**
+ * Generic conditional If statements.
+ * Nested `else if` need to be desugared into `else { if ... }`
+ * @example
+ * if (condition) { ... } else { ... }
+ * @category Expressions
+ */
+export declare class If extends ASTNode {
+    /** @hidden */
+    elseExpr: Expression;
+    /** @hidden */
+    then: Expression;
+    /** @hidden */
+    condition: Expression;
+    constructor(condition: Expression, then: Expression, elseExpr: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Generic return statement.
+ * @example
+ * // In Haskell
+ * f x = x * 2
+ * // The parser takes the body and uses it as a Return
+ * @example
+ * function f(x) {
+ *    return x * 2 // The node holds this expression
+ * }
+ * @category Statements
+ */
+export declare class Return extends ASTNode {
+    /** @hidden */
+    body?: Expression;
+    constructor(body?: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Generic field in a Record statement.
+ * The name can be undefined to support positional-only Records
+ * @example
+ * ... { name :: String }
+ * @category Declarations
+ */
+export declare class Field extends ASTNode {
+    /** @hidden */
+    value: Type;
+    /** @hidden */
+    name: SymbolPrimitive | undefined;
+    constructor(name: SymbolPrimitive | undefined, value: Type, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        name: {
+            type: string;
+            value: string;
+        };
+        value: any;
+    };
+}
+/**
+ * Generic constructor node.
+ * Holds an array of Field nodes.
+ * @example
+ * data Record = Constructor { field :: String }
+ * @category Declarations
+ */
+export declare class Constructor extends ASTNode {
+    /** @hidden */
+    fields: Field[];
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, fields: Field[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        name: {
+            type: string;
+            value: string;
+        };
+        fields: {
+            type: string;
+            name: {
+                type: string;
+                value: string;
+            };
+            value: any;
+        }[];
+    };
+}
+/**
+ * Generic Record statement node.
+ * @example
+ * data Record = Constructor { field :: String }
+ * data PositionalRecord = Constructor String String
+ * @category Declarations
+ */
+export declare class Record extends ASTNode {
+    /** @hidden */
+    deriving?: SymbolPrimitive[];
+    /** @hidden */
+    contents: Constructor[];
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, contents: Constructor[], deriving?: SymbolPrimitive[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        name: {
+            type: string;
+            value: string;
+        };
+        contents: {
+            type: string;
+            name: {
+                type: string;
+                value: string;
+            };
+            fields: {
+                type: string;
+                name: {
+                    type: string;
+                    value: string;
+                };
+                value: any;
+            }[];
+        }[];
+        deriving: {
+            type: string;
+            value: string;
+        }[];
+    };
+}
+/**
+ * Represents the body of an Equation that does not have guards.
+ * Most languages match the body of its equations to it.
+ * @example
+ * f x = x + 2
+ * // The body is the `x + 2` part
+ * @example
+ * function f(x) {
+ *    return x + 2;
+ * }
+ * @category Declarations
+ */
+export declare class UnguardedBody extends ASTNode {
+    /** @hidden */
+    sequence: Sequence;
+    constructor(sequence: Sequence, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        sequence: any;
+    };
+}
+/**
+ * Represents the body of an Equation that does have guards.
+ * For example, Haskell's guards
+ * @example
+ * f x
+ *    | x > 2 = x * 2
+ *    | otherwise = x / 2
+ * @category Declarations
+ */
+export declare class GuardedBody extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    condition: Expression;
+    constructor(condition: Expression, body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents one Equation with its arguments and body. Allows for overloading and pattern matching.
+ * You may define the return statement to access it more easily.
+ *
+ * @example
+ * add 0 y = y
+ * add x y = x + y
+ * @category Declarations
+ */
+export declare class Equation extends ASTNode {
+    /** @hidden */
+    patterns: Pattern[];
+    /** @hidden */
+    body: UnguardedBody | GuardedBody[];
+    /** @hidden */
+    returnExpr?: Return;
+    constructor(patterns: Pattern[], body: UnguardedBody | GuardedBody[], returnExpr?: Return, loc?: SourceLocation);
+    /** @hidden */
+    accept<R>(visitor: Visitor<R>): R;
+    /** @hidden */
+    toJSON(): any;
+}
+/**
+ * Functional / Imperative programming function declaration.
+ * It is is composed by an identifier and one or more equations
+ * @example
+ * int foo (int bar) {
+ *    return bar;
+ * }
+ * @example
+ * def foo(bar):
+ *    return bar
+ * @category Declarations
+ */
+export declare class Function extends ASTNode {
+    /** @hidden */
+    equations: Equation[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, equations: Equation[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a case expression, selecting a branch based on pattern matching against a value.
+ *
+ * @example
+ * case x of
+ *   [] -> 0
+ *   (x:xs) -> 1 + length xs
+ * @category Expressions
+ */
+export declare class Case extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    condition: Expression;
+    constructor(condition: Expression, body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        condition: any;
+        body: any;
+    };
+}
+/**
+ * Represents a switch statement, selecting execution paths based on value equality.
+ * @category Expressions
+ */
+export declare class Switch extends ASTNode {
+    /** @hidden */
+    defaultExpr?: Expression;
+    /** @hidden */
+    cases: Case[];
+    /** @hidden */
+    value: Expression;
+    constructor(value: Expression, cases: Case[], defaultExpr?: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a catch block for handling exceptions thrown in a try block.
+ * @category Statements
+ */
+export declare class Catch extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    patterns: Pattern[];
+    constructor(patterns: Pattern[], body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        patterns: any[];
+        body: any;
+    };
+}
+/**
+ * Represents a try block, wrapping code that might throw exceptions.
+ *
+ * @example
+ * try { ... } catch e : DomainException { ... }
+ * @category Statements
+ */
+export declare class Try extends ASTNode {
+    /** @hidden */
+    finallyExpr: Expression;
+    /** @hidden */
+    catchExpr: Catch[];
+    /** @hidden */
+    body: Expression;
+    constructor(body: Expression, catchExpr: Catch[], finallyExpr: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents an explicit raising or throwing of an exception or error.
+ * @category Statements
+ */
+export declare class Raise extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    constructor(body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a command to output data to the standard output.
+ * @category Statements
+ */
+export declare class Print extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    constructor(expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a command to read input from the user or standard input.
+ * @category Statements
+ */
+export declare class Input extends ASTNode {
+    /** @hidden */
+    variable: SymbolPrimitive;
+    /** @hidden */
+    message: Expression;
+    constructor(message: Expression, variable: SymbolPrimitive, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a for-loop control structure for iterating over a sequence or range.
+ * @category Statements
+ */
+export declare class For extends ASTNode {
+    /** @hidden */
+    statements: Statement[];
+    /** @hidden */
+    body: Expression;
+    constructor(body: Expression, statements: Statement[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a control flow statement to exit the current loop immediately.
+ * @category Statements
+ */
+export declare class Break extends ASTNode {
+    /** @hidden */
+    body?: Expression;
+    constructor(body?: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a control flow statement to skip the rest of the current loop iteration.
+ * @category Statements
+ */
+export declare class Continue extends ASTNode {
+    /** @hidden */
+    body?: Expression;
+    constructor(body?: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a variable usage or reference in an expression.
+ * @category Expressions
+ */
+export declare class Variable extends ASTNode {
+    /** @hidden */
+    variableType?: Type;
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, expression: Expression, variableType?: Type, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents an assignment operation, binding a value to a variable.
+ *
+ * @example
+ * count = count + 1
+ * @category Statements
+ */
+export declare class Assignment extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a sequence of statements executed in order.
+ * @category Statements
+ */
+export declare class Sequence extends ASTNode {
+    /** @hidden */
+    statements: Statement[];
+    constructor(statements: Statement[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+export type Statement = EntryPoint | Function | Clause | Procedure | TypeAlias | TypeSignature | Class | Object | Method | Super | Attribute | Interface | Switch | Send | Try | Return | Print | Input | Raise | Structure | Break | Continue | Call | Enumeration | Variable | Assignment | Yield | Record | If | Repeat | ForLoop | While;
+export type AST = Statement[];
+export interface YukigoParser {
+    errors?: string[];
+    parse: (code: string) => AST;
+}
+export {};