yukigo-ast 0.1.0

package/dist/globals/patterns.d.ts

@@ -0,0 +1,170 @@
+import { Visitor } from "../visitor.js";
+import { ASTNode, Primitive, SourceLocation, SymbolPrimitive } from "./generics.js";
+/**
+ * Represents a pattern that matches any value and binds it to a variable.
+ *
+ * @example
+ * map (\x -> x + 1)
+ * @category Patterns
+ */
+export declare class VariablePattern extends ASTNode {
+    /** @hidden */
+    name: SymbolPrimitive;
+    constructor(name: SymbolPrimitive, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        name: {
+            type: string;
+            value: string;
+        };
+    };
+}
+/**
+ * Represents a pattern that matches an exact literal value.
+ * @category Patterns
+ */
+export declare class LiteralPattern extends ASTNode {
+    /** @hidden */
+    name: Primitive;
+    constructor(name: Primitive, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        name: {
+            type: string;
+            value: string;
+        } | {
+            type: string;
+            value: number;
+        } | {
+            type: string;
+            value: boolean;
+        } | {
+            type: string;
+            value: import("./generics.js").Expression[];
+        };
+    };
+}
+/**
+ * Represents a pattern matching a function application or constructor with arguments.
+ * @category Patterns
+ */
+export declare class ApplicationPattern extends ASTNode {
+    /** @hidden */
+    args: Pattern[];
+    /** @hidden */
+    symbol: SymbolPrimitive;
+    constructor(symbol: SymbolPrimitive, args: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a pattern matching a tuple structure.
+ * @category Patterns
+ */
+export declare class TuplePattern extends ASTNode {
+    /** @hidden */
+    elements: Pattern[];
+    constructor(elements: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a pattern matching a list structure.
+ *
+ * @example
+ * sum (x:xs) = x + sum xs
+ * @category Patterns
+ */
+export declare class ListPattern extends ASTNode {
+    /** @hidden */
+    elements: Pattern[];
+    constructor(elements: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a pattern matching a functor or compound term.
+ * @category Patterns
+ */
+export declare class FunctorPattern extends ASTNode {
+    /** @hidden */
+    args: Pattern[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, args: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents an alias pattern (e.g., x@pat), binding the whole value to a name while matching inner patterns.
+ *
+ * @example
+ * f p@(x, y) = ...
+ * @category Patterns
+ */
+export declare class AsPattern extends ASTNode {
+    /** @hidden */
+    pattern: Pattern;
+    /** @hidden */
+    alias: VariablePattern | WildcardPattern;
+    constructor(alias: VariablePattern | WildcardPattern, pattern: Pattern, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a wildcard pattern (_), which matches anything and discards the value.
+ *
+ * @example
+ * const _ x = x
+ * @category Patterns
+ */
+export declare class WildcardPattern extends ASTNode {
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        name: string;
+    };
+}
+/**
+ * Represents a union of patterns, matching if any of the sub-patterns match.
+ * @category Patterns
+ */
+export declare class UnionPattern extends ASTNode {
+    /** @hidden */
+    patterns: Pattern[];
+    constructor(patterns: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a pattern matching a specific data constructor.
+ *
+ * @example
+ * safeDiv (Just x) y = x / y
+ * @category Patterns
+ */
+export declare class ConstructorPattern extends ASTNode {
+    /** @hidden */
+    patterns: Pattern[];
+    /** @hidden */
+    constr: string;
+    constructor(constr: string, patterns: Pattern[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a pattern matching the head and tail of a list (x:xs).
+ * @category Patterns
+ */
+export declare class ConsPattern extends ASTNode {
+    /** @hidden */
+    tail: Pattern;
+    /** @hidden */
+    head: Pattern;
+    constructor(head: Pattern, tail: Pattern, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+export type Pattern = VariablePattern | LiteralPattern | ApplicationPattern | TuplePattern | ListPattern | FunctorPattern | AsPattern | WildcardPattern | ConstructorPattern | UnionPattern | ConsPattern;

package/dist/globals/patterns.js

@@ -0,0 +1,261 @@
+import { ASTNode, } from "./generics.js";
+/**
+ * Represents a pattern that matches any value and binds it to a variable.
+ *
+ * @example
+ * map (\x -> x + 1)
+ * @category Patterns
+ */
+export class VariablePattern extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitVariablePattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "VariablePattern",
+            name: this.name.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a pattern that matches an exact literal value.
+ * @category Patterns
+ */
+export class LiteralPattern extends ASTNode {
+    /** @hidden */
+    name;
+    constructor(name, loc) {
+        super(loc);
+        this.name = name;
+    }
+    accept(visitor) {
+        return visitor.visitLiteralPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "LiteralPattern",
+            name: this.name.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a pattern matching a function application or constructor with arguments.
+ * @category Patterns
+ */
+export class ApplicationPattern extends ASTNode {
+    /** @hidden */
+    args;
+    /** @hidden */
+    symbol;
+    constructor(symbol, args, loc) {
+        super(loc);
+        this.symbol = symbol;
+        this.args = args;
+    }
+    accept(visitor) {
+        return visitor.visitApplicationPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ApplicationPattern",
+            symbol: this.symbol.toJSON(),
+            args: this.args.map((arg) => arg.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a pattern matching a tuple structure.
+ * @category Patterns
+ */
+export class TuplePattern extends ASTNode {
+    /** @hidden */
+    elements;
+    constructor(elements, loc) {
+        super(loc);
+        this.elements = elements;
+    }
+    accept(visitor) {
+        return visitor.visitTuplePattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "TuplePattern",
+            elements: this.elements.map((elem) => elem.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a pattern matching a list structure.
+ *
+ * @example
+ * sum (x:xs) = x + sum xs
+ * @category Patterns
+ */
+export class ListPattern extends ASTNode {
+    /** @hidden */
+    elements;
+    constructor(elements, loc) {
+        super(loc);
+        this.elements = elements;
+    }
+    accept(visitor) {
+        return visitor.visitListPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ListPattern",
+            elements: this.elements.map((elem) => elem.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a pattern matching a functor or compound term.
+ * @category Patterns
+ */
+export class FunctorPattern extends ASTNode {
+    /** @hidden */
+    args;
+    /** @hidden */
+    identifier;
+    constructor(identifier, args, loc) {
+        super(loc);
+        this.identifier = identifier;
+        this.args = args;
+    }
+    accept(visitor) {
+        return visitor.visitFunctorPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "FunctorPattern",
+            identifier: this.identifier.toJSON(),
+            args: this.args.map((arg) => arg.toJSON()),
+        };
+    }
+}
+/**
+ * Represents an alias pattern (e.g., x@pat), binding the whole value to a name while matching inner patterns.
+ *
+ * @example
+ * f p@(x, y) = ...
+ * @category Patterns
+ */
+export class AsPattern extends ASTNode {
+    /** @hidden */
+    pattern;
+    /** @hidden */
+    alias;
+    constructor(alias, pattern, loc) {
+        super(loc);
+        this.alias = alias;
+        this.pattern = pattern;
+    }
+    accept(visitor) {
+        return visitor.visitAsPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "AsPattern",
+            alias: this.alias.toJSON(),
+            pattern: this.pattern.toJSON(),
+        };
+    }
+}
+/**
+ * Represents a wildcard pattern (_), which matches anything and discards the value.
+ *
+ * @example
+ * const _ x = x
+ * @category Patterns
+ */
+export class WildcardPattern extends ASTNode {
+    accept(visitor) {
+        return visitor.visitWildcardPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "WildcardPattern",
+            name: "_",
+        };
+    }
+}
+/**
+ * Represents a union of patterns, matching if any of the sub-patterns match.
+ * @category Patterns
+ */
+export class UnionPattern extends ASTNode {
+    /** @hidden */
+    patterns;
+    constructor(patterns, loc) {
+        super(loc);
+        this.patterns = patterns;
+    }
+    accept(visitor) {
+        return visitor.visitUnionPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "UnionPattern",
+            patterns: this.patterns.map((pattern) => pattern.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a pattern matching a specific data constructor.
+ *
+ * @example
+ * safeDiv (Just x) y = x / y
+ * @category Patterns
+ */
+export class ConstructorPattern extends ASTNode {
+    /** @hidden */
+    patterns;
+    /** @hidden */
+    constr;
+    constructor(constr, patterns, loc) {
+        super(loc);
+        this.constr = constr;
+        this.patterns = patterns;
+    }
+    accept(visitor) {
+        return visitor.visitConstructorPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ConstructorPattern",
+            constructor: this.constr,
+            patterns: this.patterns.map((pattern) => pattern.toJSON()),
+        };
+    }
+}
+/**
+ * Represents a pattern matching the head and tail of a list (x:xs).
+ * @category Patterns
+ */
+export class ConsPattern extends ASTNode {
+    /** @hidden */
+    tail;
+    /** @hidden */
+    head;
+    constructor(head, tail, loc) {
+        super(loc);
+        this.head = head;
+        this.tail = tail;
+    }
+    accept(visitor) {
+        return visitor.visitConsPattern?.(this);
+    }
+    toJSON() {
+        return {
+            type: "ConsPattern",
+            head: this.head.toJSON(),
+            tail: this.tail.toJSON(),
+        };
+    }
+}

package/dist/globals/runtime.d.ts

@@ -0,0 +1,22 @@
+import { GuardedBody, PrimitiveValue, UnguardedBody } from "./generics.js";
+import { Pattern } from "./patterns.js";
+export interface EquationRuntime {
+    patterns: Pattern[];
+    body: GuardedBody[] | UnguardedBody;
+}
+export type PrimitiveThunk = () => PrimitiveValue;
+/**
+ * Runtime Function used in the Interpreter
+ */
+export interface RuntimeFunction {
+    arity: number;
+    identifier?: string;
+    equations: EquationRuntime[];
+    pendingArgs?: (PrimitiveValue | PrimitiveThunk)[];
+    closure?: Map<string, PrimitiveValue>[];
+}
+export interface LazyList {
+    readonly type: "LazyList";
+    readonly generator: () => Generator<PrimitiveValue, void, unknown>;
+}
+export declare function isLazyList(prim: PrimitiveValue): prim is LazyList;

package/dist/globals/runtime.js

@@ -0,0 +1,6 @@
+export function isLazyList(prim) {
+    return (prim &&
+        typeof prim === "object" &&
+        "type" in prim &&
+        prim.type === "LazyList");
+}

package/dist/globals/types.d.ts

@@ -0,0 +1,185 @@
+import { Visitor } from "../visitor.js";
+import { ASTNode, Expression, SourceLocation, SymbolPrimitive } from "./generics.js";
+export type Type = SimpleType | TypeVar | ListType | TypeApplication | TupleType | ParameterizedType | ConstrainedType;
+/**
+ * Represents a basic named type (e.g., Int, Bool).
+ * @category Types
+ */
+export declare class SimpleType extends ASTNode {
+    /** @hidden */
+    constraints: Constraint[];
+    /** @hidden */
+    value: string;
+    constructor(value: string, constraints: Constraint[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toString(): string;
+    toJSON(): any;
+}
+/**
+ * Represents a type variable (e.g., 'a), used in polymorphic types.
+ * @category Types
+ */
+export declare class TypeVar extends ASTNode {
+    /** @hidden */
+    constraints: Constraint[];
+    /** @hidden */
+    value: string;
+    constructor(value: string, constraints: Constraint[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toString(): string;
+    toJSON(): {
+        type: string;
+        value: string;
+        constraints: any[];
+    };
+}
+/**
+ * Represents the application of a type constructor to arguments (e.g., List Int).
+ * @category Types
+ */
+export declare class TypeApplication extends ASTNode {
+    /** @hidden */
+    argument: Type;
+    /** @hidden */
+    functionType: Type;
+    constructor(functionType: Type, argument: Type, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toString(): string;
+    toJSON(): any;
+}
+/**
+ * Represents a list type (e.g., [Int]).
+ * @category Types
+ */
+export declare class ListType extends ASTNode {
+    /** @hidden */
+    constraints: Constraint[];
+    /** @hidden */
+    values: Type;
+    constructor(values: Type, constraints: Constraint[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toString(): string;
+    toJSON(): any;
+}
+/**
+ * Represents a tuple type (e.g., (Int, Bool)).
+ * @category Types
+ */
+export declare class TupleType extends ASTNode {
+    /** @hidden */
+    constraints: Constraint[];
+    /** @hidden */
+    values: Type[];
+    constructor(values: Type[], constraints: Constraint[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toString(): string;
+    toJSON(): any;
+}
+/**
+ * Represents a type constraint or class constraint (e.g., Eq a).
+ *
+ * @example
+ * (Eq a) => a -> a -> Bool
+ * @category Types
+ */
+export declare class Constraint extends ASTNode {
+    /** @hidden */
+    parameters: Type[];
+    /** @hidden */
+    name: string;
+    constructor(name: string, parameters: Type[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}
+/**
+ * Represents a type that accepts type parameters.
+ * @category Types
+ */
+export declare class ParameterizedType extends ASTNode {
+    /** @hidden */
+    constraints: Constraint[];
+    /** @hidden */
+    returnType: Type;
+    /** @hidden */
+    inputs: Type[];
+    constructor(inputs: Type[], returnType: Type, constraints: Constraint[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toString(): any;
+    toJSON(): any;
+}
+/**
+ * Represents a type qualified by a context of constraints.
+ * @category Types
+ */
+export declare class ConstrainedType extends ASTNode {
+    /** @hidden */
+    constraints: Constraint[];
+    constructor(constraints: Constraint[], loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        constraints: any[];
+    };
+}
+/**
+ * Represents a type alias definition, giving a new name to an existing type.
+ *
+ * @example
+ * type String = [Char]
+ * @category Types
+ */
+export declare class TypeAlias extends ASTNode {
+    /** @hidden */
+    value: Type;
+    /** @hidden */
+    variables: string[];
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, variables: string[], value: Type, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        variables: string[];
+        value: any;
+    };
+}
+/**
+ * Represents an explicit type signature declaration for a function or variable.
+ *
+ * @example
+ * add :: Int -> Int -> Int
+ * @category Types
+ */
+export declare class TypeSignature extends ASTNode {
+    /** @hidden */
+    body: Type;
+    /** @hidden */
+    identifier: SymbolPrimitive;
+    constructor(identifier: SymbolPrimitive, body: Type, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): {
+        type: string;
+        identifier: {
+            type: string;
+            value: string;
+        };
+        body: any;
+    };
+}
+/**
+ * Represents an explicit type casting or annotation expression.
+ * @category Types
+ */
+export declare class TypeCast extends ASTNode {
+    /** @hidden */
+    body: Type;
+    /** @hidden */
+    expression: Expression;
+    constructor(expression: Expression, body: Type, loc?: SourceLocation);
+    accept<R>(visitor: Visitor<R>): R;
+    toJSON(): any;
+}