yukigo-ast 0.1.0

package/dist/paradigms/imperative.js

@@ -0,0 +1,188 @@
+import { ASTNode, } from "../globals/generics.js";
+/**
+ * Represents the main entry point of a program.
+ * @category Declarations
+ */
+export class EntryPoint extends ASTNode {
+    /** @hidden */
+    expression;
+    /** @hidden */
+    identifier;
+    constructor(identifier, expression, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitEntryPoint?.(this);
+    }
+    toJSON() {
+        return {
+            type: "EntryPoint",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a procedure definition, typically a function without a return value.
+ * @category Declarations
+ */
+export class Procedure extends ASTNode {
+    /** @hidden */
+    equations;
+    /** @hidden */
+    identifier;
+    constructor(identifier, equations, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.equations = equations;
+    }
+    accept(visitor) {
+        return visitor.visitProcedure?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Procedure",
+            identifier: this.identifier.toJSON(),
+            equations: this.equations.map((eq) => eq.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a definition of a structured data type (struct).
+ * @category Declarations
+ */
+export class Structure extends ASTNode {
+    /** @hidden */
+    elements;
+    /** @hidden */
+    identifier;
+    constructor(identifier, elements, loc) {
+        super();
+        this.identifier = identifier;
+        this.elements = elements;
+        this.loc = loc;
+    }
+    accept(visitor) {
+        return visitor.visitStructure?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Structure",
+            identifier: this.identifier.toJSON(),
+            expressions: this.elements.map((elem) => elem.toJSON()),
+        };
+    }
+}
+/**
+ * Represents an enumeration type definition.
+ * @category Declarations
+ */
+export class Enumeration extends ASTNode {
+    /** @hidden */
+    contents;
+    /** @hidden */
+    identifier;
+    constructor(identifier, contents, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.contents = contents;
+    }
+    accept(visitor) {
+        return visitor.visitEnumeration?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Enumeration",
+            identifier: this.identifier.toJSON(),
+            expressions: this.contents.map((c) => c.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a while loop control structure.
+ *
+ * @example
+ * while (x > 0) { ... }
+ * @category Statements
+ */
+export class While extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    condition;
+    constructor(condition, body, loc) {
+        super(loc);
+        this.condition = condition;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitWhile?.(this);
+    }
+    toJSON() {
+        return {
+            type: "While",
+            condition: this.condition.toJSON(),
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a repeat-until loop control structure.
+ * @category Statements
+ */
+export class Repeat extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    count;
+    constructor(count, body, loc) {
+        super(loc);
+        this.count = count;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitRepeat?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Repeat",
+            count: this.count.toJSON(),
+            body: this.body.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a C-style or range-based for loop.
+ * @category Statements
+ */
+export class ForLoop extends ASTNode {
+    /** @hidden */
+    body;
+    /** @hidden */
+    update;
+    /** @hidden */
+    condition;
+    /** @hidden */
+    initialization;
+    constructor(initialization, condition, update, body, loc) {
+        super(loc);
+        this.initialization = initialization;
+        this.condition = condition;
+        this.update = update;
+        this.body = body;
+    }
+    accept(visitor) {
+        return visitor.visitForLoop?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ForLoop",
+            initialization: this.initialization.toJSON(),
+            condition: this.condition.toJSON(),
+            update: this.update.toJSON(),
+            body: this.body.toJSON(),
+        };
+    }
+}

package/dist/paradigms/logic.d.ts

@@ -0,0 +1,163 @@
+import { ASTNode, Expression, Primitive, PrimitiveValue, SourceLocation, SymbolPrimitive } from "../globals/generics.js";
+import { Pattern } from "../globals/patterns.js";
+import { Visitor } from "../visitor.js";
+export type Clause = Rule | Fact | Query | Primitive;
+/**
+ * Represents a logic programming rule (Head :- Body).
+ *
+ * @example
+ * grandparent(X, Z) :- parent(X, Y), parent(Y, Z).
+ * @category Logic
+ */
+export declare class Rule extends ASTNode {
+    /** @hidden */
+    expressions: Expression[];
+    /** @hidden */
+    patterns: Pattern[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, patterns: Pattern[], expressions: Expression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a call to a predicate or goal.
+ * @category Logic
+ */
+export declare class Call extends ASTNode {
+    /** @hidden */
+    args: Expression[];
+    /** @hidden */
+    callee: SymbolPrimitive;
+    constructor(callee: SymbolPrimitive, args: Expression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a fact, a rule with no body (always true).
+ *
+ * @example
+ * human(socrates).
+ * @category Logic
+ */
+export declare class Fact extends ASTNode {
+    /** @hidden */
+    patterns: Pattern[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, patterns: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        patterns: any[];
+    };
+}
+/**
+ * Represents a query or goal to be proven.
+ *
+ * @example
+ * ?- human(X).
+ * @category Logic
+ */
+export declare class Query extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    constructor(expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents an existential quantification.
+ * @category Logic
+ */
+export declare class Exist extends ASTNode {
+    /** @hidden */
+    patterns: Pattern[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, patterns: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        patterns: any[];
+    };
+}
+/**
+ * Represents logical negation or failure-as-negation.
+ * @category Logic
+ */
+export declare class Not extends ASTNode {
+    /** @hidden */
+    expressions: Expression[];
+    constructor(expressions: Expression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a higher-order predicate finding all solutions (e.g., findall/3).
+ * @category Logic
+ */
+export declare class Findall extends ASTNode {
+    /** @hidden */
+    bag: Expression;
+    /** @hidden */
+    goal: Expression;
+    /** @hidden */
+    template: Expression;
+    constructor(template: Expression, goal: Expression, bag: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a universal quantification or forall predicate.
+ * @category Logic
+ */
+export declare class Forall extends ASTNode {
+    /** @hidden */
+    action: Expression;
+    /** @hidden */
+    condition: Expression;
+    constructor(condition: Expression, action: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a single goal within a logical rule or query.
+ * @category Logic
+ */
+export declare class Goal extends ASTNode {
+    /** @hidden */
+    args: Pattern[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, args: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        arguments: any[];
+    };
+}
+export type RuntimePredicate = RuntimeFact | RuntimeRule;
+export declare const isRuntimePredicate: (prim: PrimitiveValue) => prim is RuntimePredicate;
+export interface RuntimeFact {
+    kind: "Fact";
+    identifier: string;
+    equations: Fact[];
+}
+export interface RuntimeRule {
+    kind: "Rule";
+    identifier: string;
+    equations: Rule[];
+}

package/dist/paradigms/logic.js

@@ -0,0 +1,240 @@
+import { ASTNode, } from "../globals/generics.js";
+/**
+ * Represents a logic programming rule (Head :- Body).
+ *
+ * @example
+ * grandparent(X, Z) :- parent(X, Y), parent(Y, Z).
+ * @category Logic
+ */
+export class Rule extends ASTNode {
+    /** @hidden */
+    expressions;
+    /** @hidden */
+    patterns;
+    /** @hidden */
+    identifier;
+    constructor(identifier, patterns, expressions, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.patterns = patterns;
+        this.expressions = expressions;
+    }
+    accept(visitor) {
+        return visitor.visitRule?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Rule",
+            identifier: this.identifier.toJSON(),
+            patterns: this.patterns.map((p) => p.toJSON()),
+            expressions: this.expressions.map((expr) => expr.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a call to a predicate or goal.
+ * @category Logic
+ */
+export class Call extends ASTNode {
+    /** @hidden */
+    args;
+    /** @hidden */
+    callee;
+    constructor(callee, args, loc) {
+        super(loc);
+        this.callee = callee;
+        this.args = args;
+    }
+    accept(visitor) {
+        return visitor.visitCall?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Call",
+            callee: this.callee.toJSON(),
+            patterns: this.args.map((p) => p.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a fact, a rule with no body (always true).
+ *
+ * @example
+ * human(socrates).
+ * @category Logic
+ */
+export class Fact extends ASTNode {
+    /** @hidden */
+    patterns;
+    /** @hidden */
+    identifier;
+    constructor(identifier, patterns, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.patterns = patterns;
+    }
+    accept(visitor) {
+        return visitor.visitFact?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Fact",
+            identifier: this.identifier.toJSON(),
+            patterns: this.patterns.map((p) => p.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a query or goal to be proven.
+ *
+ * @example
+ * ?- human(X).
+ * @category Logic
+ */
+export class Query extends ASTNode {
+    /** @hidden */
+    expression;
+    constructor(expression, loc) {
+        super(loc);
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitQuery?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Query",
+            expression: this.expression.toJSON(),
+        };
+    }
+}
+/**
+ * Represents an existential quantification.
+ * @category Logic
+ */
+export class Exist extends ASTNode {
+    /** @hidden */
+    patterns;
+    /** @hidden */
+    identifier;
+    constructor(identifier, patterns, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.patterns = patterns;
+    }
+    accept(visitor) {
+        return visitor.visitExist?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Exist",
+            identifier: this.identifier.toJSON(),
+            patterns: this.patterns.map((p) => p.toJSON()),
+        };
+    }
+}
+/**
+ * Represents logical negation or failure-as-negation.
+ * @category Logic
+ */
+export class Not extends ASTNode {
+    /** @hidden */
+    expressions;
+    constructor(expressions, loc) {
+        super(loc);
+        this.expressions = expressions;
+    }
+    accept(visitor) {
+        return visitor.visitNot?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Not",
+            expressions: this.expressions.map((expr) => expr.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a higher-order predicate finding all solutions (e.g., findall/3).
+ * @category Logic
+ */
+export class Findall extends ASTNode {
+    /** @hidden */
+    bag;
+    /** @hidden */
+    goal;
+    /** @hidden */
+    template;
+    constructor(template, goal, bag, loc) {
+        super(loc);
+        this.template = template;
+        this.goal = goal;
+        this.bag = bag;
+    }
+    accept(visitor) {
+        return visitor.visitFindall?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Findall",
+            template: this.template.toJSON(),
+            goal: this.goal.toJSON(),
+            bag: this.bag.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a universal quantification or forall predicate.
+ * @category Logic
+ */
+export class Forall extends ASTNode {
+    /** @hidden */
+    action;
+    /** @hidden */
+    condition;
+    constructor(condition, action, loc) {
+        super(loc);
+        this.condition = condition;
+        this.action = action;
+    }
+    accept(visitor) {
+        return visitor.visitForall?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Forall",
+            condition: this.condition.toJSON(),
+            action: this.action.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a single goal within a logical rule or query.
+ * @category Logic
+ */
+export class Goal extends ASTNode {
+    /** @hidden */
+    args;
+    /** @hidden */
+    identifier;
+    constructor(identifier, args, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.args = args;
+    }
+    accept(visitor) {
+        return visitor.visitGoal?.(this);
+    }
+    toJSON() {
+        return {
+            type: "Goal",
+            identifier: this.identifier.toJSON(),
+            arguments: this.args.map((arg) => arg.toJSON()),
+        };
+    }
+}
+export const isRuntimePredicate = (prim) => {
+    return (typeof prim === "object" &&
+        "kind" in prim &&
+        (prim.kind === "Fact" || prim.kind === "Rule"));
+};