yukigo-ast 0.1.0

package/dist/visitor.d.ts

@@ -0,0 +1,254 @@
+import { Sequence, NumberPrimitive, BooleanPrimitive, StringPrimitive, ListPrimitive, NilPrimitive, SymbolPrimitive, CharPrimitive, TupleExpression, FieldExpression, DataExpression, ConsExpression, LetInExpression, Otherwise, ListComprehension, RangeExpression, If, Return, Field, Constructor, UnguardedBody, GuardedBody, Equation, Switch, Try, Raise, Print, Function, Generator, For, Break, Continue, Variable, Assignment, ASTNode, Record, Case, Catch, Input } from "./globals/generics.js";
+import { ArithmeticUnaryOperation, ArithmeticBinaryOperation, ListUnaryOperation, ListBinaryOperation, ComparisonOperation, LogicalBinaryOperation, LogicalUnaryOperation, StringOperation, UnifyOperation, AssignOperation, BitwiseBinaryOperation, BitwiseUnaryOperation } from "./globals/operators.js";
+import { VariablePattern, LiteralPattern, ApplicationPattern, TuplePattern, ListPattern, FunctorPattern, AsPattern, WildcardPattern, UnionPattern, ConstructorPattern, ConsPattern } from "./globals/patterns.js";
+import { SimpleType, TypeVar, TypeApplication, ListType, TupleType, Constraint, ParameterizedType, ConstrainedType, TypeAlias, TypeSignature, TypeCast } from "./globals/types.js";
+import { AlterDatabase, AlterTable, Commit, CreateDatabase, CreateIndex, CreateTable, Delete, DropIndex, DropTable, InsertInto, Rollback, Select, Update } from "./paradigms/data.js";
+import { CompositionExpression, Lambda, Application, Yield } from "./paradigms/functional.js";
+import { EntryPoint, Procedure, Enumeration, While, Repeat, ForLoop, Structure } from "./paradigms/imperative.js";
+import { Call, Exist, Not, Findall, Forall, Goal, Rule, Fact, Query } from "./paradigms/logic.js";
+import { Send, New, Implement, Include, Self, Method, Attribute, Class, Interface, Object, Super, PrimitiveMethod } from "./paradigms/object.js";
+export interface StrictVisitor<TReturn> {
+    visitSequence(node: Sequence): TReturn;
+    visitNumberPrimitive(node: NumberPrimitive): TReturn;
+    visitBooleanPrimitive(node: BooleanPrimitive): TReturn;
+    visitStringPrimitive(node: StringPrimitive): TReturn;
+    visitListPrimitive(node: ListPrimitive): TReturn;
+    visitNilPrimitive(node: NilPrimitive): TReturn;
+    visitSymbolPrimitive(node: SymbolPrimitive): TReturn;
+    visitCharPrimitive(node: CharPrimitive): TReturn;
+    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): TReturn;
+    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): TReturn;
+    visitListUnaryOperation(node: ListUnaryOperation): TReturn;
+    visitListBinaryOperation(node: ListBinaryOperation): TReturn;
+    visitComparisonOperation(node: ComparisonOperation): TReturn;
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): TReturn;
+    visitLogicalUnaryOperation(node: LogicalUnaryOperation): TReturn;
+    visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): TReturn;
+    visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): TReturn;
+    visitStringOperation(node: StringOperation): TReturn;
+    visitUnifyOperation(node: UnifyOperation): TReturn;
+    visitAssignOperation(node: AssignOperation): TReturn;
+    visitTupleExpr(node: TupleExpression): TReturn;
+    visitFieldExpr(node: FieldExpression): TReturn;
+    visitDataExpr(node: DataExpression): TReturn;
+    visitConsExpr(node: ConsExpression): TReturn;
+    visitLetInExpr(node: LetInExpression): TReturn;
+    visitCall(node: Call): TReturn;
+    visitOtherwise(node: Otherwise): TReturn;
+    visitCompositionExpression(node: CompositionExpression): TReturn;
+    visitLambda(node: Lambda): TReturn;
+    visitApplication(node: Application): TReturn;
+    visitExist(node: Exist): TReturn;
+    visitNot(node: Not): TReturn;
+    visitFindall(node: Findall): TReturn;
+    visitForall(node: Forall): TReturn;
+    visitGoal(node: Goal): TReturn;
+    visitSend(node: Send): TReturn;
+    visitNew(node: New): TReturn;
+    visitImplement(node: Implement): TReturn;
+    visitInclude(node: Include): TReturn;
+    visitListComprehension(node: ListComprehension): TReturn;
+    visitGenerator(node: Generator): TReturn;
+    visitRangeExpression(node: RangeExpression): TReturn;
+    visitSelf(node: Self): TReturn;
+    visitSuper(node: Super): TReturn;
+    visitYield(node: Yield): TReturn;
+    visitIf(node: If): TReturn;
+    visitReturn(node: Return): TReturn;
+    visitFunction(node: Function): TReturn;
+    visitField(node: Field): TReturn;
+    visitConstructor(node: Constructor): TReturn;
+    visitRecord(node: Record): TReturn;
+    visitUnguardedBody(node: UnguardedBody): TReturn;
+    visitGuardedBody(node: GuardedBody): TReturn;
+    visitEquation(node: Equation): TReturn;
+    visitSwitch(node: Switch): TReturn;
+    visitCase(node: Case): TReturn;
+    visitTry(node: Try): TReturn;
+    visitCatch(node: Catch): TReturn;
+    visitRaise(node: Raise): TReturn;
+    visitPrint(node: Print): TReturn;
+    visitInput(node: Input): TReturn;
+    visitFor(node: For): TReturn;
+    visitBreak(node: Break): TReturn;
+    visitContinue(node: Continue): TReturn;
+    visitVariable(node: Variable): TReturn;
+    visitAssignment(node: Assignment): TReturn;
+    visitStructure(node: Structure): TReturn;
+    visitEntryPoint(node: EntryPoint): TReturn;
+    visitProcedure(node: Procedure): TReturn;
+    visitEnumeration(node: Enumeration): TReturn;
+    visitWhile(node: While): TReturn;
+    visitRepeat(node: Repeat): TReturn;
+    visitForLoop(node: ForLoop): TReturn;
+    visitRule(node: Rule): TReturn;
+    visitFact(node: Fact): TReturn;
+    visitQuery(node: Query): TReturn;
+    visitMethod(node: Method): TReturn;
+    visitPrimitiveMethod(node: PrimitiveMethod): TReturn;
+    visitAttribute(node: Attribute): TReturn;
+    visitObject(node: Object): TReturn;
+    visitClass(node: Class): TReturn;
+    visitInterface(node: Interface): TReturn;
+    visitVariablePattern(node: VariablePattern): TReturn;
+    visitLiteralPattern(node: LiteralPattern): TReturn;
+    visitApplicationPattern(node: ApplicationPattern): TReturn;
+    visitTuplePattern(node: TuplePattern): TReturn;
+    visitListPattern(node: ListPattern): TReturn;
+    visitFunctorPattern(node: FunctorPattern): TReturn;
+    visitAsPattern(node: AsPattern): TReturn;
+    visitWildcardPattern(node: WildcardPattern): TReturn;
+    visitUnionPattern(node: UnionPattern): TReturn;
+    visitConstructorPattern(node: ConstructorPattern): TReturn;
+    visitConsPattern(node: ConsPattern): TReturn;
+    visitSimpleType(node: SimpleType): TReturn;
+    visitTypeVar(node: TypeVar): TReturn;
+    visitTypeApplication(node: TypeApplication): TReturn;
+    visitListType(node: ListType): TReturn;
+    visitTupleType(node: TupleType): TReturn;
+    visitConstraint(node: Constraint): TReturn;
+    visitParameterizedType(node: ParameterizedType): TReturn;
+    visitConstrainedType(node: ConstrainedType): TReturn;
+    visitTypeAlias(node: TypeAlias): TReturn;
+    visitTypeSignature(node: TypeSignature): TReturn;
+    visitTypeCast(node: TypeCast): TReturn;
+    visitSelect(node: Select): TReturn;
+    visitUpdate(node: Update): TReturn;
+    visitDelete(node: Delete): TReturn;
+    visitInsertInto(node: InsertInto): TReturn;
+    visitCreateDatabase(node: CreateDatabase): TReturn;
+    visitAlterDatabase(node: AlterDatabase): TReturn;
+    visitCreateTable(node: CreateTable): TReturn;
+    visitAlterTable(node: AlterTable): TReturn;
+    visitDropTable(node: DropTable): TReturn;
+    visitCreateIndex(node: CreateIndex): TReturn;
+    visitDropIndex(node: DropIndex): TReturn;
+    visitCommit(node: Commit): TReturn;
+    visitRollback(node: Rollback): TReturn;
+    visit(node: ASTNode): TReturn;
+}
+export type Visitor<R> = Partial<StrictVisitor<R>>;
+export declare class StopTraversalException extends Error {
+    constructor();
+}
+export declare class TraverseVisitor implements StrictVisitor<void> {
+    visitSelect(node: Select): void;
+    visitUpdate(node: Update): void;
+    visitDelete(node: Delete): void;
+    visitInsertInto(node: InsertInto): void;
+    visitCreateDatabase(node: CreateDatabase): void;
+    visitAlterDatabase(node: AlterDatabase): void;
+    visitCreateTable(node: CreateTable): void;
+    visitAlterTable(node: AlterTable): void;
+    visitDropTable(node: DropTable): void;
+    visitCreateIndex(node: CreateIndex): void;
+    visitDropIndex(node: DropIndex): void;
+    visitCommit(node: Commit): void;
+    visitRollback(node: Rollback): void;
+    protected traverseCollection(nodes: ASTNode[]): void;
+    visitSequence(node: Sequence): void;
+    visitStructure(node: Structure): void;
+    visitNumberPrimitive(node: NumberPrimitive): void;
+    visitBooleanPrimitive(node: BooleanPrimitive): void;
+    visitStringPrimitive(node: StringPrimitive): void;
+    visitListPrimitive(node: ListPrimitive): void;
+    visitNilPrimitive(node: NilPrimitive): void;
+    visitSymbolPrimitive(node: SymbolPrimitive): void;
+    visitCharPrimitive(node: CharPrimitive): void;
+    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): void;
+    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): void;
+    visitListUnaryOperation(node: ListUnaryOperation): void;
+    visitListBinaryOperation(node: ListBinaryOperation): void;
+    visitComparisonOperation(node: ComparisonOperation): void;
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): void;
+    visitLogicalUnaryOperation(node: LogicalUnaryOperation): void;
+    visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): void;
+    visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): void;
+    visitStringOperation(node: StringOperation): void;
+    visitUnifyOperation(node: UnifyOperation): void;
+    visitAssignOperation(node: AssignOperation): void;
+    visitTupleExpr(node: TupleExpression): void;
+    visitFieldExpr(node: FieldExpression): void;
+    visitDataExpr(node: DataExpression): void;
+    visitConsExpr(node: ConsExpression): void;
+    visitLetInExpr(node: LetInExpression): void;
+    visitCall(node: Call): void;
+    visitOtherwise(node: Otherwise): void;
+    visitCompositionExpression(node: CompositionExpression): void;
+    visitLambda(node: Lambda): void;
+    visitApplication(node: Application): void;
+    visitExist(node: Exist): void;
+    visitNot(node: Not): void;
+    visitFindall(node: Findall): void;
+    visitForall(node: Forall): void;
+    visitGoal(node: Goal): void;
+    visitSend(node: Send): void;
+    visitNew(node: New): void;
+    visitImplement(node: Implement): void;
+    visitInclude(node: Include): void;
+    visitSelf(node: Self): void;
+    visitSuper(node: Super): void;
+    visitListComprehension(node: ListComprehension): void;
+    visitGenerator(node: Generator): void;
+    visitRangeExpression(node: RangeExpression): void;
+    visitYield(node: Yield): void;
+    visitIf(node: If): void;
+    visitReturn(node: Return): void;
+    visitFunction(node: Function): void;
+    visitField(node: Field): void;
+    visitConstructor(node: Constructor): void;
+    visitRecord(node: Record): void;
+    visitUnguardedBody(node: UnguardedBody): void;
+    visitGuardedBody(node: GuardedBody): void;
+    visitEquation(node: Equation): void;
+    visitSwitch(node: Switch): void;
+    visitCase(node: Case): void;
+    visitTry(node: Try): void;
+    visitCatch(node: Catch): void;
+    visitRaise(node: Raise): void;
+    visitPrint(node: Print): void;
+    visitInput(node: Input): void;
+    visitFor(node: For): void;
+    visitBreak(node: Break): void;
+    visitContinue(node: Continue): void;
+    visitVariable(node: Variable): void;
+    visitAssignment(node: Assignment): void;
+    visitEntryPoint(node: EntryPoint): void;
+    visitProcedure(node: Procedure): void;
+    visitEnumeration(node: Enumeration): void;
+    visitWhile(node: While): void;
+    visitRepeat(node: Repeat): void;
+    visitForLoop(node: ForLoop): void;
+    visitRule(node: Rule): void;
+    visitFact(node: Fact): void;
+    visitQuery(node: Query): void;
+    visitMethod(node: Method): void;
+    visitPrimitiveMethod(node: PrimitiveMethod): void;
+    visitAttribute(node: Attribute): void;
+    visitObject(node: Object): void;
+    visitClass(node: Class): void;
+    visitInterface(node: Interface): void;
+    visitVariablePattern(node: VariablePattern): void;
+    visitLiteralPattern(node: LiteralPattern): void;
+    visitApplicationPattern(node: ApplicationPattern): void;
+    visitTuplePattern(node: TuplePattern): void;
+    visitListPattern(node: ListPattern): void;
+    visitFunctorPattern(node: FunctorPattern): void;
+    visitAsPattern(node: AsPattern): void;
+    visitWildcardPattern(node: WildcardPattern): void;
+    visitUnionPattern(node: UnionPattern): void;
+    visitConstructorPattern(node: ConstructorPattern): void;
+    visitConsPattern(node: ConsPattern): void;
+    visitSimpleType(node: SimpleType): void;
+    visitTypeVar(node: TypeVar): void;
+    visitTypeApplication(node: TypeApplication): void;
+    visitListType(node: ListType): void;
+    visitTupleType(node: TupleType): void;
+    visitConstraint(node: Constraint): void;
+    visitParameterizedType(node: ParameterizedType): void;
+    visitConstrainedType(node: ConstrainedType): void;
+    visitTypeAlias(node: TypeAlias): void;
+    visitTypeSignature(node: TypeSignature): void;
+    visitTypeCast(node: TypeCast): void;
+    visit(node: ASTNode): void;
+}

package/dist/visitor.js

@@ -0,0 +1,426 @@
+export class StopTraversalException extends Error {
+    constructor() {
+        super("Inspection found, aborting traversal.");
+    }
+}
+export class TraverseVisitor {
+    visitSelect(node) {
+        this.traverseCollection(node.columns);
+        node.where?.accept(this);
+    }
+    visitUpdate(node) {
+        this.traverseCollection(node.assignments);
+        node.where?.accept(this);
+    }
+    visitDelete(node) {
+        node.where?.accept(this);
+    }
+    visitInsertInto(node) {
+        node.values.forEach((val) => this.traverseCollection(val));
+    }
+    visitCreateDatabase(node) { }
+    visitAlterDatabase(node) { }
+    visitCreateTable(node) {
+        this.traverseCollection(node.columns);
+    }
+    visitAlterTable(node) {
+        node.action.accept(this);
+    }
+    visitDropTable(node) { }
+    visitCreateIndex(node) { }
+    visitDropIndex(node) { }
+    visitCommit(node) {
+        node.name.accept(this);
+    }
+    visitRollback(node) {
+        node.name.accept(this);
+    }
+    traverseCollection(nodes) {
+        for (const node of nodes) {
+            try {
+                node.accept(this);
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+    }
+    visitSequence(node) {
+        this.traverseCollection(node.statements);
+    }
+    visitStructure(node) {
+        this.traverseCollection(node.elements);
+    }
+    visitNumberPrimitive(node) { }
+    visitBooleanPrimitive(node) { }
+    visitStringPrimitive(node) { }
+    visitListPrimitive(node) {
+        this.traverseCollection(node.elements);
+    }
+    visitNilPrimitive(node) { }
+    visitSymbolPrimitive(node) { }
+    visitCharPrimitive(node) { }
+    visitArithmeticUnaryOperation(node) {
+        node.operand.accept(this);
+    }
+    visitArithmeticBinaryOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitListUnaryOperation(node) {
+        node.operand.accept(this);
+    }
+    visitListBinaryOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitComparisonOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitLogicalBinaryOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitLogicalUnaryOperation(node) {
+        node.operand.accept(this);
+    }
+    visitBitwiseBinaryOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitBitwiseUnaryOperation(node) {
+        node.operand.accept(this);
+    }
+    visitStringOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitUnifyOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitAssignOperation(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitTupleExpr(node) {
+        this.traverseCollection(node.elements);
+    }
+    visitFieldExpr(node) {
+        node.name.accept(this);
+        node.expression.accept(this);
+    }
+    visitDataExpr(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.contents);
+    }
+    visitConsExpr(node) {
+        node.head.accept(this);
+        node.tail.accept(this);
+    }
+    visitLetInExpr(node) {
+        node.expression.accept(this);
+        node.declarations.accept(this);
+    }
+    visitCall(node) {
+        node.callee.accept(this);
+        this.traverseCollection(node.args);
+    }
+    visitOtherwise(node) { }
+    visitCompositionExpression(node) {
+        node.left.accept(this);
+        node.right.accept(this);
+    }
+    visitLambda(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.parameters);
+    }
+    visitApplication(node) {
+        node.functionExpr.accept(this);
+        node.parameter.accept(this);
+    }
+    visitExist(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.patterns);
+    }
+    visitNot(node) {
+        this.traverseCollection(node.expressions);
+    }
+    visitFindall(node) {
+        node.template.accept(this);
+        node.goal.accept(this);
+        node.bag.accept(this);
+    }
+    visitForall(node) {
+        node.condition.accept(this);
+        node.action.accept(this);
+    }
+    visitGoal(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+    }
+    visitSend(node) {
+        node.selector.accept(this);
+        node.receiver.accept(this);
+        this.traverseCollection(node.args);
+    }
+    visitNew(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+    }
+    visitImplement(node) {
+        node.identifier.accept(this);
+    }
+    visitInclude(node) {
+        node.identifier.accept(this);
+    }
+    visitSelf(node) { }
+    visitSuper(node) { }
+    visitListComprehension(node) {
+        node.projection.accept(this);
+        this.traverseCollection(node.generators);
+    }
+    visitGenerator(node) {
+        node.variable.accept(this);
+        node.expression.accept(this);
+    }
+    visitRangeExpression(node) {
+        node.start.accept(this);
+        node.step?.accept(this);
+        node.end?.accept(this);
+    }
+    visitYield(node) {
+        node.expression.accept(this);
+    }
+    visitIf(node) {
+        node.condition.accept(this);
+        node.then.accept(this);
+        node.elseExpr.accept(this);
+    }
+    visitReturn(node) {
+        node.body.accept(this);
+    }
+    visitFunction(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+    }
+    visitField(node) {
+        node.name?.accept(this);
+        node.value.accept(this);
+    }
+    visitConstructor(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.fields);
+    }
+    visitRecord(node) {
+        node.name.accept(this);
+        this.traverseCollection(node.contents);
+        if (node.deriving)
+            this.traverseCollection(node.deriving);
+    }
+    visitUnguardedBody(node) {
+        node.sequence.accept(this);
+    }
+    visitGuardedBody(node) {
+        node.condition.accept(this);
+        node.body.accept(this);
+    }
+    visitEquation(node) {
+        if (Array.isArray(node.body)) {
+            this.traverseCollection(node.body);
+        }
+        else {
+            node.body.accept(this);
+        }
+        this.traverseCollection(node.patterns);
+        node.returnExpr?.accept(this);
+    }
+    visitSwitch(node) {
+        node.value.accept(this);
+        this.traverseCollection(node.cases);
+    }
+    visitCase(node) {
+        node.condition.accept(this);
+        node.body.accept(this);
+    }
+    visitTry(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.catchExpr);
+        node.finallyExpr.accept(this);
+    }
+    visitCatch(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.patterns);
+    }
+    visitRaise(node) {
+        node.body.accept(this);
+    }
+    visitPrint(node) {
+        node.expression.accept(this);
+    }
+    visitInput(node) {
+        node.message.accept(this);
+    }
+    visitFor(node) {
+        node.body.accept(this);
+        this.traverseCollection(node.statements);
+    }
+    visitBreak(node) {
+        node.body.accept(this);
+    }
+    visitContinue(node) {
+        node.body.accept(this);
+    }
+    visitVariable(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+        node.variableType?.accept(this);
+    }
+    visitAssignment(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+    }
+    visitEntryPoint(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+    }
+    visitProcedure(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+    }
+    visitEnumeration(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.contents);
+    }
+    visitWhile(node) {
+        node.condition.accept(this);
+        node.body.accept(this);
+    }
+    visitRepeat(node) {
+        node.body.accept(this);
+        node.count.accept(this);
+    }
+    visitForLoop(node) {
+        node.initialization.accept(this);
+        node.condition.accept(this);
+        node.update.accept(this);
+        node.body.accept(this);
+    }
+    visitRule(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.expressions);
+        this.traverseCollection(node.patterns);
+    }
+    visitFact(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.patterns);
+    }
+    visitQuery(node) {
+        node.expression.accept(this);
+    }
+    visitMethod(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.equations);
+    }
+    visitPrimitiveMethod(node) {
+        this.traverseCollection(node.equations);
+    }
+    visitAttribute(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+    }
+    visitObject(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+    }
+    visitClass(node) {
+        node.identifier.accept(this);
+        node.expression.accept(this);
+        node.extendsSymbol?.accept(this);
+        node.implementsNode?.accept(this);
+    }
+    visitInterface(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.extendsSymbol);
+        node.expression.accept(this);
+    }
+    visitVariablePattern(node) {
+        node.name.accept(this);
+    }
+    visitLiteralPattern(node) {
+        node.name.accept(this);
+    }
+    visitApplicationPattern(node) {
+        node.symbol.accept(this);
+        this.traverseCollection(node.args);
+    }
+    visitTuplePattern(node) {
+        this.traverseCollection(node.elements);
+    }
+    visitListPattern(node) {
+        this.traverseCollection(node.elements);
+    }
+    visitFunctorPattern(node) {
+        node.identifier.accept(this);
+        this.traverseCollection(node.args);
+    }
+    visitAsPattern(node) {
+        node.alias.accept(this);
+        node.pattern.accept(this);
+    }
+    visitWildcardPattern(node) { }
+    visitUnionPattern(node) {
+        this.traverseCollection(node.patterns);
+    }
+    visitConstructorPattern(node) {
+        this.traverseCollection(node.patterns);
+    }
+    visitConsPattern(node) {
+        node.head.accept(this);
+        node.tail.accept(this);
+    }
+    visitSimpleType(node) {
+        this.traverseCollection(node.constraints);
+    }
+    visitTypeVar(node) {
+        this.traverseCollection(node.constraints);
+    }
+    visitTypeApplication(node) {
+        node.functionType.accept(this);
+        node.argument.accept(this);
+    }
+    visitListType(node) {
+        this.traverseCollection(node.constraints);
+    }
+    visitTupleType(node) {
+        this.traverseCollection(node.constraints);
+        this.traverseCollection(node.values);
+    }
+    visitConstraint(node) {
+        this.traverseCollection(node.parameters);
+    }
+    visitParameterizedType(node) {
+        this.traverseCollection(node.inputs);
+        this.traverseCollection(node.constraints);
+        node.returnType.accept(this);
+    }
+    visitConstrainedType(node) {
+        this.traverseCollection(node.constraints);
+    }
+    visitTypeAlias(node) {
+        node.identifier.accept(this);
+        node.value.accept(this);
+    }
+    visitTypeSignature(node) {
+        node.body.accept(this);
+        node.identifier.accept(this);
+    }
+    visitTypeCast(node) {
+        node.body.accept(this);
+        node.expression.accept(this);
+    }
+    visit(node) {
+        node.accept(this);
+    }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "yukigo-ast",
+  "version": "0.1.0",
+  "description": "",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "noiseArch",
+  "license": "ISC",
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.2"
+  }
+}