yukigo-ast 0.1.0 → 0.2.0

package/.mocharc.json

@@ -0,0 +1,4 @@
+{
+  "extension": ["ts"],
+  "spec": "tests/**/*.spec.ts"
+}

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.2.0 (2026-04-11)
+
+### 🚀 Features
+
+- **yukigo-ast:** agrego metodo is ASTNode ([6a63873](https://github.com/miyukiproject/yukigo/commit/6a63873))
+
+### ❤️ Thank You
+
+- Santiago Schneideroff
+
 ## 0.1.0 (2025-12-09)
 
 ### 🚀 Features

package/dist/globals/expressions.d.ts

@@ -0,0 +1,170 @@
+import { CompositionExpression, Lambda, Application } from "../paradigms/functional.js";
+import { Exist, Forall, Findall, Not } from "../paradigms/logic.js";
+import { Self, New, Implement } from "../paradigms/object.js";
+import { Visitor } from "../visitor/index.js";
+import { ASTNode, SourceLocation } from "./generics.js";
+import { Operation } from "./operators.js";
+import { SymbolPrimitive, Primitive } from "./primitives.js";
+import { Sequence, Print, For } from "./statements.js";
+import { Assertion } from "./testing.js";
+import { TypeCast } from "./types.js";
+/**
+ * Represent tuples - generic non-uniform fixed-size collection of elements
+ *
+ * @example
+ * (1, "Hello", true)
+ * @category Expressions
+ */
+export declare class TupleExpression extends ASTNode {
+    /** @hidden */
+    elements: Expression[];
+    constructor(elements: Expression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Fields of a data expression representations
+ * @category Expressions
+ */
+export declare class FieldExpression extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Data expression, used to construct Records
+ * @example
+ * f = DataName { fieldName = 2 }
+ * @category Expressions
+ */
+export declare class DataExpression extends ASTNode {
+    /** @hidden */
+    contents: FieldExpression[];
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, contents: FieldExpression[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Cons expression, represent a concatenation of a head and a tail
+ * @example
+ * f = x : xs
+ * @category Expressions
+ */
+export declare class ConsExpression extends ASTNode {
+    /** @hidden */
+    tail: Expression;
+    /** @hidden */
+    head: Expression;
+    constructor(head: Expression, tail: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represent let...in expressions normally used in Haskell
+ * @example
+ * f = let x = 2 in x * 4
+ * @category Expressions
+ */
+export declare class LetInExpression extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    declarations: Sequence;
+    constructor(declarations: Sequence, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        declarations: any;
+        expression: any;
+    };
+}
+/**
+ * Otherwise used as the default case in GuardBody
+ * @example
+ * f x
+ *  | x == 2 = 16
+ *  | otherwise = x * 8
+ * @category Declarations
+ */
+export declare class Otherwise extends ASTNode {
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+    };
+}
+/**
+ * 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 declare class ListComprehension extends ASTNode {
+    /** @hidden */
+    generators: (Generator | Expression)[];
+    /** @hidden */
+    projection: Expression;
+    constructor(projection: Expression, generators: (Generator | Expression)[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Generator represents patterns like "Just m <- ms" or "x <- [1,2,3]"
+ * @example
+ * x <- [1, 2, 3, 4]
+ * @category Declarations
+ */
+export declare class Generator extends ASTNode {
+    /** @hidden */
+    expression: Expression;
+    /** @hidden */
+    variable: SymbolPrimitive;
+    constructor(variable: SymbolPrimitive, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * 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 declare class RangeExpression extends ASTNode {
+    /** @hidden */
+    step?: Expression;
+    /** @hidden */
+    end?: Expression;
+    /** @hidden */
+    start: Expression;
+    constructor(start: Expression, end?: Expression, // undefined for infinite ranges like [0..]
+    step?: Expression, // for [start, second .. end] syntax
+    loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+export declare class NamedArgument extends ASTNode {
+    identifier: SymbolPrimitive;
+    expression: Expression;
+    constructor(identifier: SymbolPrimitive, expression: Expression, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: import("./primitives.js").YukigoPrimitive;
+            value: string;
+        };
+        expression: any;
+    };
+}
+export type Expression = Primitive | Operation | TupleExpression | Print | Otherwise | ConsExpression | Self | Sequence | New | Implement | DataExpression | CompositionExpression | Lambda | For | Application | Exist | Forall | Findall | Not | TypeCast | ListComprehension | RangeExpression | Assertion;
+//# sourceMappingURL=expressions.d.ts.map

package/dist/globals/expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/globals/expressions.ts"],"names":[],"mappings":"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"}

package/dist/globals/expressions.js

@@ -0,0 +1,260 @@
+import { ASTNode } from "./generics.js";
+/**
+ * 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 class NamedArgument extends ASTNode {
+    identifier;
+    expression;
+    constructor(identifier, expression, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitNamedArgument?.(this);
+    }
+    toJSON() {
+        return {
+            type: "NamedArgument",
+            identifier: this.identifier.toJSON(),
+            expression: this.expression.toJSON(),
+        };
+    }
+}