yukigo-ast 0.1.0

package/src/paradigms/imperative.ts

@@ -0,0 +1,232 @@
+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 class EntryPoint extends ASTNode {
+  /** @hidden */
+  public expression: Sequence;
+  /** @hidden */
+  public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    expression: Sequence,
+    loc?: SourceLocation
+  ) {
+    super(loc);
+    this.identifier = identifier;
+    this.expression = expression;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitEntryPoint?.(this);
+  }
+  public 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 */
+  public equations: Equation[];
+  /** @hidden */
+  public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    equations: Equation[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+    this.identifier = identifier;
+    this.equations = equations;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitProcedure?.(this);
+  }
+  public 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 */
+  public elements: (Variable | Structure)[];
+  /** @hidden */
+  public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    elements: (Variable | Structure)[],
+    loc?: SourceLocation
+  ) {
+    super();
+    this.identifier = identifier;
+    this.elements = elements;
+    this.loc = loc;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitStructure?.(this);
+  }
+  public 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 */
+  public contents: SymbolPrimitive[];
+  /** @hidden */
+  public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    contents: SymbolPrimitive[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+    this.identifier = identifier;
+    this.contents = contents;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitEnumeration?.(this);
+  }
+  public 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 */
+  public body: Expression;
+  /** @hidden */
+  public condition: Expression;
+
+  constructor(condition: Expression, body: Expression, loc?: SourceLocation) {
+    super(loc);
+    this.condition = condition;
+    this.body = body;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitWhile?.(this);
+  }
+  public 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 */
+  public body: Expression;
+  /** @hidden */
+  public count: Expression;
+
+  constructor(count: Expression, body: Expression, loc?: SourceLocation) {
+    super(loc);
+    this.count = count;
+    this.body = body;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitRepeat?.(this);
+  }
+  public 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 */
+  public body: Expression;
+  /** @hidden */
+  public update: Expression;
+  /** @hidden */
+  public condition: Expression;
+  /** @hidden */
+  public initialization: Expression;
+
+  constructor(
+    initialization: Expression,
+    condition: Expression,
+    update: Expression,
+    body: Expression,
+    loc?: SourceLocation
+  ) {
+    super(loc);
+    this.initialization = initialization;
+    this.condition = condition;
+    this.update = update;
+    this.body = body;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitForLoop?.(this);
+  }
+  public toJSON() {
+    return {
+      type: "ForLoop",
+      initialization: this.initialization.toJSON(),
+      condition: this.condition.toJSON(),
+      update: this.update.toJSON(),
+      body: this.body.toJSON(),
+    };
+  }
+}

package/src/paradigms/logic.ts

@@ -0,0 +1,314 @@
+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 class Rule extends ASTNode {
+    /** @hidden */
+    public expressions: Expression[];
+    /** @hidden */
+    public patterns: Pattern[];
+    /** @hidden */
+    public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    patterns: Pattern[],
+    expressions: Expression[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.identifier = identifier;
+      this.patterns = patterns;
+      this.expressions = expressions;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitRule?.(this);
+  }
+  public 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 */
+    public args: Expression[];
+    /** @hidden */
+    public callee: SymbolPrimitive;
+
+  constructor(
+    callee: SymbolPrimitive,
+    args: Expression[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.callee = callee;
+      this.args = args;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitCall?.(this);
+  }
+  public 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 */
+    public patterns: Pattern[];
+    /** @hidden */
+    public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    patterns: Pattern[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.identifier = identifier;
+      this.patterns = patterns;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitFact?.(this);
+  }
+  public 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 */
+    public expression: Expression;
+
+  constructor(expression: Expression, loc?: SourceLocation) {
+    super(loc);
+      this.expression = expression;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitQuery?.(this);
+  }
+  public toJSON() {
+    return {
+      type: "Query",
+      expression: this.expression.toJSON(),
+    };
+  }
+}
+
+/**
+ * Represents an existential quantification.
+ * @category Logic
+ */
+export class Exist extends ASTNode {
+    /** @hidden */
+    public patterns: Pattern[];
+    /** @hidden */
+    public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    patterns: Pattern[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.identifier = identifier;
+      this.patterns = patterns;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitExist?.(this);
+  }
+  public 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 */
+    public expressions: Expression[];
+
+  constructor(expressions: Expression[], loc?: SourceLocation) {
+    super(loc);
+      this.expressions = expressions;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitNot?.(this);
+  }
+  public 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 */
+    public bag: Expression;
+    /** @hidden */
+    public goal: Expression;
+    /** @hidden */
+    public template: Expression;
+
+  constructor(
+    template: Expression,
+    goal: Expression,
+    bag: Expression,
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.template = template;
+      this.goal = goal;
+      this.bag = bag;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitFindall?.(this);
+  }
+  public 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 */
+    public action: Expression;
+    /** @hidden */
+    public condition: Expression;
+
+  constructor(
+    condition: Expression,
+    action: Expression,
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.condition = condition;
+      this.action = action;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitForall?.(this);
+  }
+  public 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 */
+    public args: Pattern[];
+    /** @hidden */
+    public identifier: SymbolPrimitive;
+
+  constructor(
+    identifier: SymbolPrimitive,
+    args: Pattern[],
+    loc?: SourceLocation
+  ) {
+    super(loc);
+      this.identifier = identifier;
+      this.args = args;
+  }
+  public accept<R>(visitor: Visitor<R>): R {
+    return visitor.visitGoal?.(this);
+  }
+  public toJSON() {
+    return {
+      type: "Goal",
+      identifier: this.identifier.toJSON(),
+      arguments: this.args.map((arg) => arg.toJSON()),
+    };
+  }
+}
+
+// Runtime Types
+
+export type RuntimePredicate = RuntimeFact | RuntimeRule;
+
+export const isRuntimePredicate = (prim: PrimitiveValue): prim is RuntimePredicate => {
+  return (
+    typeof prim === "object" &&
+    "kind" in prim &&
+    (prim.kind === "Fact" || prim.kind === "Rule")
+  );
+};
+
+export interface RuntimeFact {
+  kind: "Fact";
+  identifier: string;
+  equations: Fact[];
+}
+export interface RuntimeRule {
+  kind: "Rule";
+  identifier: string;
+  equations: Rule[];
+}