yukigo-ast 0.1.0

package/dist/paradigms/data.js

@@ -0,0 +1,348 @@
+import { ASTNode } from "../globals/generics.js";
+/**
+ * Represents a query to retrieve data from a database table.
+ * @category SQL
+ * @example
+ * SELECT * FROM users WHERE age > 18
+ */
+export class Select extends ASTNode {
+    /** @hidden */
+    columns;
+    /** @hidden */
+    from;
+    /** @hidden */
+    where;
+    constructor(columns, from, where, loc) {
+        super(loc);
+        this.columns = columns;
+        this.from = from;
+        this.where = where;
+    }
+    accept(visitor) {
+        return visitor.visitSelect?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Select",
+            columns: this.columns.map((c) => c.toJSON()),
+            from: this.from,
+            where: this.where.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a command to modify existing records in a database table.
+ * @category SQL
+ * @example
+ * UPDATE products SET price = 10 WHERE id = 1
+ */
+export class Update extends ASTNode {
+    /** @hidden */
+    table;
+    /** @hidden */
+    assignments;
+    /** @hidden */
+    where;
+    constructor(table, assignments, where, loc) {
+        super(loc);
+        this.table = table;
+        this.assignments = assignments;
+        this.where = where;
+    }
+    accept(visitor) {
+        return visitor.visitUpdate?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Update",
+            table: this.table,
+            assignments: this.assignments.map((assign) => assign.toJSON()),
+            where: this.where.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a command to remove records from a database table.
+ * @category SQL
+ * @example
+ * DELETE FROM sessions WHERE last_active < '2023-01-01'
+ */
+export class Delete extends ASTNode {
+    /** @hidden */
+    table;
+    /** @hidden */
+    where;
+    constructor(table, where, loc) {
+        super(loc);
+        this.table = table;
+        this.where = where;
+    }
+    accept(visitor) {
+        return visitor.visitDelete?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Delete",
+            table: this.table,
+            where: this.where.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a command to insert new records into a database table.
+ * @category SQL
+ * @example
+ * INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
+ */
+export class InsertInto extends ASTNode {
+    /** @hidden */
+    table;
+    /** @hidden */
+    columns;
+    /** @hidden */
+    values;
+    constructor(table, columns, values, loc) {
+        super(loc);
+        this.table = table;
+        this.columns = columns;
+        this.values = values;
+    }
+    accept(visitor) {
+        return visitor.visitInsertInto?.(this);
+    }
+    toJSON() {
+        return {
+            type: "InsertInto",
+            table: this.table,
+            columns: this.columns,
+            values: this.values.map((val) => val.map((v) => v.toJSON())),
+        };
+    }
+}
+/**
+ * Represents a command to create a new database container.
+ * @category SQL
+ * @example
+ * CREATE DATABASE production_db
+ */
+export class CreateDatabase extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitCreateDatabase?.(this);
+    }
+    toJSON() {
+        return {
+            type: "CreateDatabase",
+            name: this.name,
+        };
+    }
+}
+/**
+ * Represents a command to modify the properties of an existing database.
+ * @category SQL
+ * @example
+ * ALTER DATABASE production_db SET READ_ONLY = OFF
+ */
+export class AlterDatabase extends ASTNode {
+    /** @hidden */
+    name;
+    /** @hidden */
+    action;
+    constructor(name, action, loc) {
+        super(loc);
+        this.name = name;
+        this.action = action;
+    }
+    accept(visitor) {
+        return visitor.visitAlterDatabase?.(this);
+    }
+    toJSON() {
+        return {
+            type: "AlterDatabase",
+            name: this.name,
+            action: this.action,
+        };
+    }
+}
+/**
+ * Represents a command to define a new table and its schema.
+ * @category SQL
+ * @example
+ * CREATE TABLE employees (id INT, name VARCHAR(100))
+ */
+export class CreateTable extends ASTNode {
+    /** @hidden */
+    name;
+    /** @hidden */
+    columns;
+    constructor(name, columns, loc) {
+        super(loc);
+        this.name = name;
+        this.columns = columns;
+    }
+    accept(visitor) {
+        return visitor.visitCreateTable?.(this);
+    }
+    toJSON() {
+        return {
+            type: "CreateTable",
+            name: this.name,
+            columns: this.columns.map((c) => c.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a command to modify an existing table structure (e.g., adding columns).
+ * @category SQL
+ * @example
+ * ALTER TABLE employees ADD COLUMN email VARCHAR(255)
+ */
+export class AlterTable extends ASTNode {
+    /** @hidden */
+    name;
+    /** @hidden */
+    action;
+    constructor(name, action, loc) {
+        super(loc);
+        this.name = name;
+        this.action = action;
+    }
+    accept(visitor) {
+        return visitor.visitAlterTable?.(this);
+    }
+    toJSON() {
+        return {
+            type: "AlterTable",
+            name: this.name,
+            action: this.action.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a command to delete a table and all its data permanently.
+ * @category SQL
+ * @example
+ * DROP TABLE old_logs
+ */
+export class DropTable extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitDropTable?.(this);
+    }
+    toJSON() {
+        return {
+            type: "DropTable",
+            name: this.name,
+        };
+    }
+}
+/**
+ * Represents a command to create a search index on table columns to improve query performance.
+ * @category SQL
+ * @example
+ * CREATE INDEX idx_lastname ON employees (lastname)
+ */
+export class CreateIndex extends ASTNode {
+    /** @hidden */
+    name;
+    /** @hidden */
+    table;
+    /** @hidden */
+    columns;
+    constructor(name, table, columns, loc) {
+        super(loc);
+        this.name = name;
+        this.table = table;
+        this.columns = columns;
+    }
+    accept(visitor) {
+        return visitor.visitCreateIndex?.(this);
+    }
+    toJSON() {
+        return {
+            type: "CreateIndex",
+            name: this.name,
+            table: this.table,
+            columns: this.columns,
+        };
+    }
+}
+/**
+ * Represents a command to remove an existing search index.
+ * @category SQL
+ * @example
+ * DROP INDEX idx_lastname
+ */
+export class DropIndex extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitDropIndex?.(this);
+    }
+    toJSON() {
+        return {
+            type: "DropIndex",
+            name: this.name,
+        };
+    }
+}
+/**
+ * Represents a command to save changes made in a transaction.
+ * @category SQL
+ * @example
+ * COMMIT TRAN transaction_name
+ */
+export class Commit extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitCommit?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Commit",
+            name: this.name,
+        };
+    }
+}
+/**
+ * Represents a command to undo changes made in a transaction.
+ * @category SQL
+ * @example
+ * ROLLBACK TRAN transaction_name
+ */
+export class Rollback extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitRollback?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Rollback",
+            name: this.name,
+        };
+    }
+}

package/dist/paradigms/functional.d.ts

@@ -0,0 +1,59 @@
+import { ASTNode, Expression, SourceLocation } from "../globals/generics.js";
+import { Pattern } from "../globals/patterns.js";
+import { Visitor } from "../visitor.js";
+/**
+ * Represents function composition (e.g., f . g).
+ * @category Expressions
+ */
+export declare class CompositionExpression extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    constructor(left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents an anonymous function or lambda abstraction.
+ *
+ * @example
+ * \x -> x + 1
+ * @category Expressions
+ */
+export declare class Lambda extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    parameters: Pattern[];
+    constructor(parameters: Pattern[], body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a yield statement, often used in generators or coroutines.
+ * @category Statements
+ */
+export declare class Yield extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    constructor(expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents the application of a function to an argument.
+ *
+ * @example
+ * map (*2) [1..5]
+ * @category Expressions
+ */
+export declare class Application extends ASTNode {
+    /** @hidden */
+    parameter: Expression;
+    /** @hidden */
+    functionExpr: Expression;
+    constructor(functionExpr: Expression, parameter: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}

package/dist/paradigms/functional.js

@@ -0,0 +1,103 @@
+import { ASTNode, } from "../globals/generics.js";
+/**
+ * Represents function composition (e.g., f . g).
+ * @category Expressions
+ */
+export class CompositionExpression extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    constructor(left, right, loc) {
+        super(loc);
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitCompositionExpression?.(this);
+    }
+    toJSON() {
+        return {
+            type: "CompositionExpression",
+            left: this.left.toJSON(),
+            right: this.right.toJSON(),
+        };
+    }
+}
+/**
+ * Represents an anonymous function or lambda abstraction.
+ *
+ * @example
+ * \x -> x + 1
+ * @category Expressions
+ */
+export class Lambda extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    parameters;
+    constructor(parameters, body, loc) {
+        super(loc);
+        this.parameters = parameters;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitLambda?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Lambda",
+            body: this.body.toJSON(),
+            parameters: this.parameters.map((p) => p.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a yield statement, often used in generators or coroutines.
+ * @category Statements
+ */
+export class Yield extends ASTNode {
+    /** @hidden */
+    expression;
+    constructor(expression, loc) {
+        super(loc);
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitYield?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Yield",
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Represents the application of a function to an argument.
+ *
+ * @example
+ * map (*2) [1..5]
+ * @category Expressions
+ */
+export class Application extends ASTNode {
+    /** @hidden */
+    parameter;
+    /** @hidden */
+    functionExpr;
+    constructor(functionExpr, parameter, loc) {
+        super(loc);
+        this.functionExpr = functionExpr;
+        this.parameter = parameter;
+    }
+    accept(visitor) {
+        return visitor.visitApplication?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Application",
+            function: this.functionExpr.toJSON(),
+            parameter: this.parameter.toJSON(),
+        };
+    }
+}

package/dist/paradigms/imperative.d.ts

@@ -0,0 +1,124 @@
+import { ASTNode, Equation, Expression, Sequence, SourceLocation, SymbolPrimitive, Variable } from "../globals/generics.js";
+import { Visitor } from "../visitor.js";
+/**
+ * Represents the main entry point of a program.
+ * @category Declarations
+ */
+export declare class EntryPoint extends ASTNode {
+    /** @hidden */
+    expression: Sequence;
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, expression: Sequence, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        expression: any;
+    };
+}
+/**
+ * Represents a procedure definition, typically a function without a return value.
+ * @category Declarations
+ */
+export declare class Procedure extends ASTNode {
+    /** @hidden */
+    equations: Equation[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, equations: Equation[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        equations: any[];
+    };
+}
+/**
+ * Represents a definition of a structured data type (struct).
+ * @category Declarations
+ */
+export declare class Structure extends ASTNode {
+    /** @hidden */
+    elements: (Variable | Structure)[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, elements: (Variable | Structure)[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents an enumeration type definition.
+ * @category Declarations
+ */
+export declare class Enumeration extends ASTNode {
+    /** @hidden */
+    contents: SymbolPrimitive[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, contents: SymbolPrimitive[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        expressions: {
+            type: string;
+            value: string;
+        }[];
+    };
+}
+/**
+ * Represents a while loop control structure.
+ *
+ * @example
+ * while (x > 0) { ... }
+ * @category Statements
+ */
+export declare class While extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    condition: Expression;
+    constructor(condition: Expression, body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a repeat-until loop control structure.
+ * @category Statements
+ */
+export declare class Repeat extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    count: Expression;
+    constructor(count: Expression, body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a C-style or range-based for loop.
+ * @category Statements
+ */
+export declare class ForLoop extends ASTNode {
+    /** @hidden */
+    body: Expression;
+    /** @hidden */
+    update: Expression;
+    /** @hidden */
+    condition: Expression;
+    /** @hidden */
+    initialization: Expression;
+    constructor(initialization: Expression, condition: Expression, update: Expression, body: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}