yukigo-ast 0.1.0

package/dist/globals/helpers.d.ts

@@ -0,0 +1,4 @@
+import { ASTNode, Primitive } from "./generics.js";
+import { Pattern } from "./patterns.js";
+export declare function isYukigoPrimitive(node: ASTNode): node is Primitive;
+export declare function isPattern(node: ASTNode): node is Pattern;

package/dist/globals/helpers.js

@@ -0,0 +1,76 @@
+import { BooleanPrimitive, NumberPrimitive, ListPrimitive, CharPrimitive, StringPrimitive, NilPrimitive, SymbolPrimitive, } from "./generics.js";
+import { ApplicationPattern, AsPattern, ConsPattern, ConstructorPattern, FunctorPattern, ListPattern, LiteralPattern, TuplePattern, UnionPattern, VariablePattern, WildcardPattern, } from "./patterns.js";
+/* type Visitor = {
+  [key: string]: (node: ASTNode, parent?: ASTNode) => boolean | void;
+}; */
+/* export function traverse(ast: AST | ASTNode, visitor: Visitor) {
+  function runVisitor(node: ASTNode, parent?: ASTNode) {
+    if (!node || typeof node !== "object" || !("type" in node)) {
+      return false;
+    }
+
+    let stop = false;
+
+    // Check for specific node type visitor
+    if (visitor[node.type]) {
+      stop = visitor[node.type](node, parent) === true;
+    }
+
+    // Check for wildcard visitor
+    if (!stop && visitor["*"]) {
+      stop = visitor["*"](node, parent) === true;
+    }
+
+    if (stop) return true;
+
+    // Recursively visit children based on their type
+    for (const key in node) {
+      if (!node.hasOwnProperty(key)) continue;
+
+      const value = node[key];
+
+      if (!value) return false;
+
+      const items = Array.isArray(value) ? value : [value];
+
+      for (const item of items) {
+        if (typeof item === "object" && item.type && runVisitor(item, node)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  // Handle the initial AST array or a single node
+  if (Array.isArray(ast)) {
+    for (const node of ast) {
+      if (runVisitor(node)) break;
+    }
+  } else {
+    runVisitor(ast);
+  }
+} */
+// disgusting...
+export function isYukigoPrimitive(node) {
+    return (node instanceof NumberPrimitive ||
+        node instanceof BooleanPrimitive ||
+        node instanceof ListPrimitive ||
+        node instanceof CharPrimitive ||
+        node instanceof StringPrimitive ||
+        node instanceof NilPrimitive ||
+        node instanceof SymbolPrimitive);
+}
+export function isPattern(node) {
+    return (node instanceof VariablePattern ||
+        node instanceof LiteralPattern ||
+        node instanceof ApplicationPattern ||
+        node instanceof TuplePattern ||
+        node instanceof ListPattern ||
+        node instanceof FunctorPattern ||
+        node instanceof AsPattern ||
+        node instanceof WildcardPattern ||
+        node instanceof ConstructorPattern ||
+        node instanceof ConsPattern ||
+        node instanceof UnionPattern);
+}

package/dist/globals/operators.d.ts

@@ -0,0 +1,251 @@
+import { Visitor } from "../visitor.js";
+import { ASTNode, Expression, SourceLocation } from "./generics.js";
+export type ArithmeticBinaryOperator = "Plus" | "Minus" | "Multiply" | "Divide" | "Modulo" | "Power" | "Max" | "Min";
+export type ArithmeticUnaryOperator = "Round" | "Absolute" | "Ceil" | "Floor" | "Negation" | "Sqrt";
+export type ComparisonOperatorType = "Equal" | "NotEqual" | "Same" | "NotSame" | "Similar" | "NotSimilar" | "GreaterOrEqualThan" | "GreaterThan" | "LessOrEqualThan" | "LessThan";
+export type LogicalBinaryOperator = "And" | "Or";
+export type LogicalUnaryOperator = "Negation";
+export type BitwiseBinaryOperator = "BitwiseOr" | "BitwiseAnd" | "BitwiseLeftShift" | "BitwiseRightShift" | "BitwiseUnsignedRightShift" | "BitwiseXor";
+export type BitwiseUnaryOperator = "BitwiseNot";
+export type ListBinaryOperator = "Push" | "Concat" | "Inject" | "Gather" | "Collect" | "AllSatisfy" | "AnySatisfy" | "Select" | "Detect" | "GetAt" | "Count" | "Slice" | "SetAt";
+export type ListUnaryOperator = "Size" | "DetectMax" | "DetectMin" | "Flatten";
+export type UnifyOperator = "Unify";
+export type AssignOperator = "Assign";
+export type StringBinaryOperator = "Concat";
+export type UnaryOperator = ArithmeticUnaryOperator | LogicalUnaryOperator | ListUnaryOperator;
+export type BinaryOperator = ArithmeticBinaryOperator | ComparisonOperatorType | LogicalBinaryOperator | BitwiseBinaryOperator | BitwiseUnaryOperator | AssignOperator | UnifyOperator | StringBinaryOperator | ListBinaryOperator;
+export type Operator = UnaryOperator | BinaryOperator;
+/**
+ * Represents a unary arithmetic operation like negation (-x).
+ * @category Operators
+ */
+export declare class ArithmeticUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand: Expression;
+    /** @hidden */
+    operator: ArithmeticUnaryOperator;
+    constructor(operator: ArithmeticUnaryOperator, operand: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: ArithmeticUnaryOperator;
+        operand: Expression;
+    };
+}
+/**
+ * Represents a binary arithmetic operation like addition or multiplication.
+ * @category Operators
+ */
+export declare class ArithmeticBinaryOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: ArithmeticBinaryOperator;
+    constructor(operator: ArithmeticBinaryOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: ArithmeticBinaryOperator;
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents a unary operation on a list, such as getting the head or tail.
+ * @category Operators
+ */
+export declare class ListUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand: Expression;
+    /** @hidden */
+    operator: ListUnaryOperator;
+    constructor(operator: ListUnaryOperator, operand: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: ListUnaryOperator;
+        operand: Expression;
+    };
+}
+/**
+ * Represents a binary operation on lists, such as concatenation.
+ * @category Operators
+ */
+export declare class ListBinaryOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: ListBinaryOperator;
+    constructor(operator: ListBinaryOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: ListBinaryOperator;
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents a comparison between two values (e.g., >, <, ==).
+ * @category Operators
+ */
+export declare class ComparisonOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: ComparisonOperatorType;
+    constructor(operator: ComparisonOperatorType, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: ComparisonOperatorType;
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents a binary logical operation like AND or OR.
+ * @category Operators
+ */
+export declare class LogicalBinaryOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: LogicalBinaryOperator;
+    constructor(operator: LogicalBinaryOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: LogicalBinaryOperator;
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents a unary logical operation like NOT.
+ * @category Operators
+ */
+export declare class LogicalUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand: Expression;
+    /** @hidden */
+    operator: LogicalUnaryOperator;
+    constructor(operator: LogicalUnaryOperator, operand: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: "Negation";
+        operand: Expression;
+    };
+}
+/**
+ * Represents a binary bitwise operation like AND, OR, XOR.
+ * @category Operators
+ */
+export declare class BitwiseBinaryOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: BitwiseBinaryOperator;
+    constructor(operator: BitwiseBinaryOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: BitwiseBinaryOperator;
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents a unary bitwise operation like NOT (complement).
+ * @category Operators
+ */
+export declare class BitwiseUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand: Expression;
+    /** @hidden */
+    operator: BitwiseUnaryOperator;
+    constructor(operator: BitwiseUnaryOperator, operand: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: "BitwiseNot";
+        operand: Expression;
+    };
+}
+/**
+ * Represents an operation specific to string manipulation.
+ * @category Operators
+ */
+export declare class StringOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: StringBinaryOperator;
+    constructor(operator: StringBinaryOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: "Concat";
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents a unification operation (=), fundamental to logic programming.
+ *
+ * @example
+ * X = 5
+ * @category Logic
+ */
+export declare class UnifyOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: UnifyOperator;
+    constructor(operator: UnifyOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: "Unify";
+        left: Expression;
+        right: Expression;
+    };
+}
+/**
+ * Represents an in-place assignment operation (e.g., +=, -=).
+ * @category Operators
+ */
+export declare class AssignOperation extends ASTNode {
+    /** @hidden */
+    right: Expression;
+    /** @hidden */
+    left: Expression;
+    /** @hidden */
+    operator: AssignOperator;
+    constructor(operator: AssignOperator, left: Expression, right: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        operator: "Assign";
+        left: Expression;
+        right: Expression;
+    };
+}
+export type BinaryOperation = ArithmeticBinaryOperation | StringOperation | ListBinaryOperation | LogicalBinaryOperation | ComparisonOperation | UnifyOperation | AssignOperation | BitwiseBinaryOperation;
+export type UnaryOperation = ArithmeticUnaryOperation | ListUnaryOperation | LogicalUnaryOperation | BitwiseUnaryOperation;
+export type Operation = BinaryOperation | UnaryOperation;

package/dist/globals/operators.js

@@ -0,0 +1,336 @@
+import { ASTNode } from "./generics.js";
+/**
+ * Represents a unary arithmetic operation like negation (-x).
+ * @category Operators
+ */
+export class ArithmeticUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand;
+    /** @hidden */
+    operator;
+    constructor(operator, operand, loc) {
+        super(loc);
+        this.operator = operator;
+        this.operand = operand;
+    }
+    accept(visitor) {
+        return visitor.visitArithmeticUnaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ArithmeticUnaryOperation",
+            operator: this.operator,
+            operand: this.operand,
+        };
+    }
+}
+/**
+ * Represents a binary arithmetic operation like addition or multiplication.
+ * @category Operators
+ */
+export class ArithmeticBinaryOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitArithmeticBinaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ArithmeticBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents a unary operation on a list, such as getting the head or tail.
+ * @category Operators
+ */
+export class ListUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand;
+    /** @hidden */
+    operator;
+    constructor(operator, operand, loc) {
+        super(loc);
+        this.operator = operator;
+        this.operand = operand;
+    }
+    accept(visitor) {
+        return visitor.visitListUnaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ListUnaryOperation",
+            operator: this.operator,
+            operand: this.operand,
+        };
+    }
+}
+/**
+ * Represents a binary operation on lists, such as concatenation.
+ * @category Operators
+ */
+export class ListBinaryOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitListBinaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ListBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents a comparison between two values (e.g., >, <, ==).
+ * @category Operators
+ */
+export class ComparisonOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitComparisonOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ComparisonOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents a binary logical operation like AND or OR.
+ * @category Operators
+ */
+export class LogicalBinaryOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitLogicalBinaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "LogicalBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents a unary logical operation like NOT.
+ * @category Operators
+ */
+export class LogicalUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand;
+    /** @hidden */
+    operator;
+    constructor(operator, operand, loc) {
+        super(loc);
+        this.operator = operator;
+        this.operand = operand;
+    }
+    accept(visitor) {
+        return visitor.visitLogicalUnaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "LogicalUnaryOperation",
+            operator: this.operator,
+            operand: this.operand,
+        };
+    }
+}
+/**
+ * Represents a binary bitwise operation like AND, OR, XOR.
+ * @category Operators
+ */
+export class BitwiseBinaryOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitBitwiseBinaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "BitwiseBinaryOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents a unary bitwise operation like NOT (complement).
+ * @category Operators
+ */
+export class BitwiseUnaryOperation extends ASTNode {
+    /** @hidden */
+    operand;
+    /** @hidden */
+    operator;
+    constructor(operator, operand, loc) {
+        super(loc);
+        this.operator = operator;
+        this.operand = operand;
+    }
+    accept(visitor) {
+        return visitor.visitBitwiseUnaryOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "BitwiseUnaryOperation",
+            operator: this.operator,
+            operand: this.operand,
+        };
+    }
+}
+/**
+ * Represents an operation specific to string manipulation.
+ * @category Operators
+ */
+export class StringOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitStringOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "StringOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents a unification operation (=), fundamental to logic programming.
+ *
+ * @example
+ * X = 5
+ * @category Logic
+ */
+export class UnifyOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitUnifyOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "UnifyOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}
+/**
+ * Represents an in-place assignment operation (e.g., +=, -=).
+ * @category Operators
+ */
+export class AssignOperation extends ASTNode {
+    /** @hidden */
+    right;
+    /** @hidden */
+    left;
+    /** @hidden */
+    operator;
+    constructor(operator, left, right, loc) {
+        super(loc);
+        this.operator = operator;
+        this.left = left;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitAssignOperation?.(this);
+    }
+    toJSON() {
+        return {
+            type: "AssignOperation",
+            operator: this.operator,
+            left: this.left,
+            right: this.right,
+        };
+    }
+}