yukigo-ast 0.1.0

package/dist/globals/generics.js

@@ -0,0 +1,1128 @@
+/**
+ * @hidden
+ */
+export class ASTNode {
+    /** @hidden */
+    loc;
+    /** @hidden */
+    metadata = new Map();
+    constructor(loc, metadata) {
+        this.loc = loc;
+        this.metadata = metadata ?? new Map();
+    }
+    setMetadata(key, value) {
+        this.metadata.set(key, value);
+    }
+    getMetadata(key) {
+        return this.metadata.get(key);
+    }
+    hasMetadata(key) {
+        return this.metadata.has(key);
+    }
+}
+/**
+ * Generic number primitive
+ * @category Literals
+ */
+export class NumberPrimitive extends ASTNode {
+    /** @hidden */
+    value;
+    constructor(value, loc) {
+        super(loc);
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitNumberPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof NumberPrimitive))
+            return false;
+        return this.value === other.value;
+    }
+    toJSON() {
+        return {
+            type: "YuNumber",
+            value: this.value,
+        };
+    }
+}
+/**
+ * Generic boolean primitive
+ * @category Literals
+ */
+export class BooleanPrimitive extends ASTNode {
+    /** @hidden */
+    value;
+    constructor(value, loc) {
+        super(loc);
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitBooleanPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof BooleanPrimitive))
+            return false;
+        return this.value === other.value;
+    }
+    toJSON() {
+        return {
+            type: "YuBoolean",
+            value: this.value,
+        };
+    }
+}
+/**
+ * Represent lists - generic uniform variable-size collection of elements. Lists typically map to arrays, lists or sequence-like structures.
+ * @category Literals
+ */
+export class ListPrimitive extends ASTNode {
+    /** @hidden */
+    elements;
+    constructor(elements, loc) {
+        super(loc);
+        this.elements = elements;
+    }
+    accept(visitor) {
+        return visitor.visitListPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof ListPrimitive))
+            return false;
+        return this.elements.every((elem, i) => elem === other.elements[i]);
+    }
+    toJSON() {
+        return {
+            type: "YuList",
+            value: this.elements,
+        };
+    }
+}
+/**
+ * Generic char primitive
+ * @category Literals
+ */
+export class CharPrimitive extends ASTNode {
+    /** @hidden */
+    value;
+    constructor(value, loc) {
+        super(loc);
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitCharPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof CharPrimitive))
+            return false;
+        return this.value === other.value;
+    }
+    toJSON() {
+        return {
+            type: "YuChar",
+            value: this.value,
+        };
+    }
+}
+/**
+ * Generic string primitive
+ * @category Literals
+ */
+export class StringPrimitive extends ASTNode {
+    /** @hidden */
+    value;
+    constructor(value, loc) {
+        super(loc);
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitStringPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof StringPrimitive))
+            return false;
+        return this.value === other.value;
+    }
+    toJSON() {
+        return {
+            type: "YuString",
+            value: this.value,
+        };
+    }
+}
+/**
+ * Generic null/undefined primitive
+ * @category Literals
+ */
+export class NilPrimitive extends ASTNode {
+    /** @hidden */
+    value;
+    constructor(value, loc) {
+        super(loc);
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitNilPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof NilPrimitive))
+            return false;
+        return this.value === other.value;
+    }
+    toJSON() {
+        return {
+            type: "YuNil",
+            value: this.value,
+        };
+    }
+}
+/**
+ * Generic symbol primitive
+ * @category Literals
+ */
+export class SymbolPrimitive extends ASTNode {
+    /** @hidden */
+    value;
+    constructor(value, loc) {
+        super(loc);
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitSymbolPrimitive?.(this);
+    }
+    /**
+     * 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) {
+        if (!(other instanceof SymbolPrimitive))
+            return false;
+        return this.value === other.value;
+    }
+    toJSON() {
+        return {
+            type: "YuSymbol",
+            value: this.value,
+        };
+    }
+}
+/**
+ * Source location information
+ */
+export class SourceLocation {
+    line;
+    column;
+    constructor(line, column) {
+        this.line = line;
+        this.column = column;
+    }
+    toJSON() {
+        return {
+            type: "SourceLocation",
+            line: this.line,
+            column: this.column,
+        };
+    }
+}
+// Expressions
+/**
+ * Represent tuples - generic non-uniform fixed-size collection of elements
+ *
+ * @example
+ * (1, "Hello", true)
+ * @category Expressions
+ */
+export class TupleExpression extends ASTNode {
+    /** @hidden */
+    elements;
+    constructor(elements, loc) {
+        super(loc);
+        this.elements = elements;
+    }
+    accept(visitor) {
+        return visitor.visitTupleExpr?.(this);
+    }
+    toJSON() {
+        return {
+            type: "TupleExpression",
+            elements: this.elements.map((expr) => expr.toJSON()),
+        };
+    }
+}
+/**
+ * Fields of a data expression representations
+ * @category Expressions
+ */
+export class FieldExpression extends ASTNode {
+    /** @hidden */
+    expression;
+    /** @hidden */
+    name;
+    constructor(name, expression, loc) {
+        super(loc);
+        this.name = name;
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitFieldExpr?.(this);
+    }
+    toJSON() {
+        return {
+            type: "FieldExpression",
+            name: this.name.toJSON(),
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Data expression, used to construct Records
+ * @example
+ * f = DataName { fieldName = 2 }
+ * @category Expressions
+ */
+export class DataExpression extends ASTNode {
+    /** @hidden */
+    contents;
+    /** @hidden */
+    name;
+    constructor(name, contents, loc) {
+        super(loc);
+        this.name = name;
+        this.contents = contents;
+    }
+    accept(visitor) {
+        return visitor.visitDataExpr?.(this);
+    }
+    toJSON() {
+        return {
+            type: "DataExpression",
+            name: this.name.toJSON(),
+            contents: this.contents.map((expr) => expr.toJSON()),
+        };
+    }
+}
+/**
+ * Cons expression, represent a concatenation of a head and a tail
+ * @example
+ * f = x : xs
+ * @category Expressions
+ */
+export class ConsExpression extends ASTNode {
+    /** @hidden */
+    tail;
+    /** @hidden */
+    head;
+    constructor(head, tail, loc) {
+        super(loc);
+        this.head = head;
+        this.tail = tail;
+    }
+    accept(visitor) {
+        return visitor.visitConsExpr?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ConsExpression",
+            head: this.head.toJSON(),
+            tail: this.tail.toJSON(),
+        };
+    }
+}
+/**
+ * Represent let...in expressions normally used in Haskell
+ * @example
+ * f = let x = 2 in x * 4
+ * @category Expressions
+ */
+export class LetInExpression extends ASTNode {
+    /** @hidden */
+    expression;
+    /** @hidden */
+    declarations;
+    constructor(declarations, expression, loc) {
+        super(loc);
+        this.declarations = declarations;
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitLetInExpr?.(this);
+    }
+    toJSON() {
+        return {
+            type: "LetInExpression",
+            declarations: this.declarations.toJSON(),
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Otherwise used as the default case in GuardBody
+ * @example
+ * f x
+ *  | x == 2 = 16
+ *  | otherwise = x * 8
+ * @category Declarations
+ */
+export class Otherwise extends ASTNode {
+    accept(visitor) {
+        return visitor.visitOtherwise?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Otherwise",
+        };
+    }
+}
+/**
+ * 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 class ListComprehension extends ASTNode {
+    /** @hidden */
+    generators;
+    /** @hidden */
+    projection;
+    constructor(projection, generators, loc) {
+        super(loc);
+        this.projection = projection;
+        this.generators = generators;
+    }
+    accept(visitor) {
+        return visitor.visitListComprehension?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ListComprehension",
+            projection: this.projection.toJSON(),
+            generators: this.generators.map((gen) => gen.toJSON()),
+        };
+    }
+}
+/**
+ * Generator represents patterns like "Just m <- ms" or "x <- [1,2,3]"
+ * @example
+ * x <- [1, 2, 3, 4]
+ * @category Declarations
+ */
+export class Generator extends ASTNode {
+    /** @hidden */
+    expression;
+    /** @hidden */
+    variable;
+    constructor(variable, expression, loc) {
+        super(loc);
+        this.variable = variable;
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitGenerator?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Generator",
+            variable: this.variable.toJSON(),
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * 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 class RangeExpression extends ASTNode {
+    /** @hidden */
+    step;
+    /** @hidden */
+    end;
+    /** @hidden */
+    start;
+    constructor(start, end, // undefined for infinite ranges like [0..]
+    step, // for [start, second .. end] syntax
+    loc) {
+        super(loc);
+        this.start = start;
+        this.end = end;
+        this.step = step;
+    }
+    accept(visitor) {
+        return visitor.visitRangeExpression?.(this);
+    }
+    toJSON() {
+        return {
+            type: "RangeExpression",
+            start: this.start.toJSON(),
+            end: this.end?.toJSON(),
+            step: this.step?.toJSON(),
+        };
+    }
+}
+//export type Expression = {
+//  type: "Expression";
+//  body: BodyExpression;
+//};
+// Statements
+/**
+ * Generic conditional If statements.
+ * Nested `else if` need to be desugared into `else { if ... }`
+ * @example
+ * if (condition) { ... } else { ... }
+ * @category Expressions
+ */
+export class If extends ASTNode {
+    /** @hidden */
+    elseExpr;
+    /** @hidden */
+    then;
+    /** @hidden */
+    condition;
+    constructor(condition, then, elseExpr, loc) {
+        super(loc);
+        this.condition = condition;
+        this.then = then;
+        this.elseExpr = elseExpr;
+    }
+    accept(visitor) {
+        return visitor.visitIf?.(this);
+    }
+    toJSON() {
+        return {
+            type: "If",
+            condition: this.condition.toJSON(),
+            then: this.then.toJSON(),
+            else: this.elseExpr.toJSON(),
+        };
+    }
+}
+/**
+ * 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 class Return extends ASTNode {
+    /** @hidden */
+    body;
+    constructor(body = new NilPrimitive(null), loc) {
+        super(loc);
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitReturn?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Return",
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Generic field in a Record statement.
+ * The name can be undefined to support positional-only Records
+ * @example
+ * ... { name :: String }
+ * @category Declarations
+ */
+export class Field extends ASTNode {
+    /** @hidden */
+    value;
+    /** @hidden */
+    name;
+    constructor(name, value, loc) {
+        super(loc);
+        this.name = name;
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitField?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Field",
+            name: this.name.toJSON(),
+            value: this.value.toJSON(),
+        };
+    }
+}
+/**
+ * Generic constructor node.
+ * Holds an array of Field nodes.
+ * @example
+ * data Record = Constructor { field :: String }
+ * @category Declarations
+ */
+export class Constructor extends ASTNode {
+    /** @hidden */
+    fields;
+    /** @hidden */
+    name;
+    constructor(name, fields, loc) {
+        super(loc);
+        this.name = name;
+        this.fields = fields;
+    }
+    accept(visitor) {
+        return visitor.visitConstructor?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Constructor",
+            name: this.name.toJSON(),
+            fields: this.fields.map((f) => f.toJSON()),
+        };
+    }
+}
+/**
+ * Generic Record statement node.
+ * @example
+ * data Record = Constructor { field :: String }
+ * data PositionalRecord = Constructor String String
+ * @category Declarations
+ */
+export class Record extends ASTNode {
+    /** @hidden */
+    deriving;
+    /** @hidden */
+    contents;
+    /** @hidden */
+    name;
+    constructor(name, contents, deriving, loc) {
+        super(loc);
+        this.name = name;
+        this.contents = contents;
+        this.deriving = deriving;
+    }
+    accept(visitor) {
+        return visitor.visitRecord?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Record",
+            name: this.name.toJSON(),
+            contents: this.contents.map((constructor) => constructor.toJSON()),
+            deriving: this.deriving?.map((d) => d.toJSON()),
+        };
+    }
+}
+/**
+ * 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 class UnguardedBody extends ASTNode {
+    /** @hidden */
+    sequence;
+    constructor(sequence, loc) {
+        super(loc);
+        this.sequence = sequence;
+    }
+    accept(visitor) {
+        return visitor.visitUnguardedBody?.(this);
+    }
+    toJSON() {
+        return {
+            type: "UnguardedBody",
+            sequence: this.sequence.toJSON(),
+        };
+    }
+}
+/**
+ * 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 class GuardedBody extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    condition;
+    constructor(condition, body, loc) {
+        super(loc);
+        this.condition = condition;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitGuardedBody?.(this);
+    }
+    toJSON() {
+        return {
+            type: "GuardedBody",
+            condition: this.condition.toJSON(),
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * 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 class Equation extends ASTNode {
+    /** @hidden */
+    patterns;
+    /** @hidden */
+    body;
+    /** @hidden */
+    returnExpr;
+    constructor(patterns, body, returnExpr, loc) {
+        super(loc);
+        this.patterns = patterns;
+        this.body = body;
+        this.returnExpr = returnExpr;
+    }
+    /** @hidden */
+    accept(visitor) {
+        return visitor.visitEquation?.(this);
+    }
+    /** @hidden */
+    toJSON() {
+        return {
+            type: "Equation",
+            patterns: this.patterns.map((pattern) => pattern.toJSON),
+            body: Array.isArray(this.body)
+                ? this.body.map((guard) => guard.toJSON())
+                : this.body.toJSON(),
+            return: this.returnExpr.toJSON(),
+        };
+    }
+}
+/**
+ * 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 class Function extends ASTNode {
+    /** @hidden */
+    equations;
+    /** @hidden */
+    identifier;
+    constructor(identifier, equations, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.equations = equations;
+    }
+    accept(visitor) {
+        return visitor.visitFunction?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Function",
+            identifier: this.identifier.toJSON(),
+            equations: this.equations.map((eq) => eq.toJSON()),
+        };
+    }
+}
+/**
+ * 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 class Case extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    condition;
+    constructor(condition, body, loc) {
+        super(loc);
+        this.condition = condition;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitCase?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Case",
+            condition: this.condition.toJSON(),
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a switch statement, selecting execution paths based on value equality.
+ * @category Expressions
+ */
+export class Switch extends ASTNode {
+    /** @hidden */
+    defaultExpr;
+    /** @hidden */
+    cases;
+    /** @hidden */
+    value;
+    constructor(value, cases, defaultExpr, loc) {
+        super(loc);
+        this.value = value;
+        this.cases = cases;
+        this.defaultExpr = defaultExpr;
+    }
+    accept(visitor) {
+        return visitor.visitSwitch?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Switch",
+            value: this.value.toJSON(),
+            cases: this.cases.map((caseVal) => ({
+                condition: caseVal.condition.toJSON(),
+                body: caseVal.body.toJSON(),
+            })),
+            default: this.defaultExpr.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a catch block for handling exceptions thrown in a try block.
+ * @category Statements
+ */
+export class Catch extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    patterns;
+    constructor(patterns, body, loc) {
+        super(loc);
+        this.patterns = patterns;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitCatch?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Catch",
+            patterns: this.patterns.map((pat) => pat.toJSON()),
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a try block, wrapping code that might throw exceptions.
+ *
+ * @example
+ * try { ... } catch e : DomainException { ... }
+ * @category Statements
+ */
+export class Try extends ASTNode {
+    /** @hidden */
+    finallyExpr;
+    /** @hidden */
+    catchExpr;
+    /** @hidden */
+    body;
+    constructor(body, catchExpr, finallyExpr, loc) {
+        super(loc);
+        this.body = body;
+        this.catchExpr = catchExpr;
+        this.finallyExpr = finallyExpr;
+    }
+    accept(visitor) {
+        return visitor.visitTry?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Try",
+            body: this.body.toJSON(),
+            catch: this.catchExpr.map(({ patterns, body }) => ({
+                condition: patterns.map((pattern) => pattern.toJSON()),
+                body: body.toJSON(),
+            })),
+            finally: this.finallyExpr.toJSON(),
+        };
+    }
+}
+/**
+ * Represents an explicit raising or throwing of an exception or error.
+ * @category Statements
+ */
+export class Raise extends ASTNode {
+    /** @hidden */
+    body;
+    constructor(body, loc) {
+        super(loc);
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitRaise?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Raise",
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a command to output data to the standard output.
+ * @category Statements
+ */
+export class Print extends ASTNode {
+    /** @hidden */
+    expression;
+    constructor(expression, loc) {
+        super(loc);
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitPrint?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Print",
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a command to read input from the user or standard input.
+ * @category Statements
+ */
+export class Input extends ASTNode {
+    /** @hidden */
+    variable;
+    /** @hidden */
+    message;
+    constructor(message, variable, loc) {
+        super(loc);
+        this.message = message;
+        this.variable = variable;
+    }
+    accept(visitor) {
+        return visitor.visitInput?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Input",
+            message: this.message.toJSON(),
+            variable: this.variable.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a for-loop control structure for iterating over a sequence or range.
+ * @category Statements
+ */
+export class For extends ASTNode {
+    /** @hidden */
+    statements;
+    /** @hidden */
+    body;
+    constructor(body, statements, loc) {
+        super(loc);
+        this.body = body;
+        this.statements = statements;
+    }
+    accept(visitor) {
+        return visitor.visitFor?.(this);
+    }
+    toJSON() {
+        return {
+            type: "For",
+            body: this.body.toJSON(),
+            statements: this.statements.map((stmt) => stmt.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a control flow statement to exit the current loop immediately.
+ * @category Statements
+ */
+export class Break extends ASTNode {
+    /** @hidden */
+    body;
+    constructor(body = new NilPrimitive(null), loc) {
+        super(loc);
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitBreak?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Break",
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a control flow statement to skip the rest of the current loop iteration.
+ * @category Statements
+ */
+export class Continue extends ASTNode {
+    /** @hidden */
+    body;
+    constructor(body = new NilPrimitive(null), loc) {
+        super(loc);
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitContinue?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Continue",
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a variable usage or reference in an expression.
+ * @category Expressions
+ */
+export class Variable extends ASTNode {
+    /** @hidden */
+    variableType;
+    /** @hidden */
+    expression;
+    /** @hidden */
+    identifier;
+    constructor(identifier, expression, variableType, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.expression = expression;
+        this.variableType = variableType;
+    }
+    accept(visitor) {
+        return visitor.visitVariable?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Variable",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON(),
+            variableType: this.variableType.toJSON(),
+        };
+    }
+}
+/**
+ * Represents an assignment operation, binding a value to a variable.
+ *
+ * @example
+ * count = count + 1
+ * @category Statements
+ */
+export class Assignment extends ASTNode {
+    /** @hidden */
+    expression;
+    /** @hidden */
+    identifier;
+    constructor(identifier, expression, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitAssignment?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Assignment",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a sequence of statements executed in order.
+ * @category Statements
+ */
+export class Sequence extends ASTNode {
+    /** @hidden */
+    statements;
+    constructor(statements, loc) {
+        super(loc);
+        this.statements = statements;
+    }
+    accept(visitor) {
+        return visitor.visitSequence?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Sequence",
+            statements: this.statements.map((stmt) => stmt.toJSON()),
+        };
+    }
+}
+/* export interface Match {
+  type: "Match";
+  condition: Expression;
+  body: Equation[];
+}
+
+export interface Arrow {
+  type: "Arrow";
+  expression1: Expression[];
+  expression2: Expression[];
+}
+ */