ast

type Callable[T any] interface {
	Arity() int
	Call(ExprVisitor[T], ...T) T
}

type Expr[T any] interface {
	Accept(v ExprVisitor[T]) T
}

type ExprAssign[T any] struct {
	Name  token.Token
	Value Expr[T]
}

type ExprBinary[T any] struct {
	Left  Expr[T]
	Token token.Token
	Right Expr[T]
}

type ExprCall[T any] struct {
	Callee    Expr[T]
	Param     token.Token
	Arguments []Expr[T]
}

type ExprGrouping[T any] struct {
	Expression Expr[T]
}

type ExprLiteral[T any] struct {
	Value any
}

type ExprLogical[T any] struct {
	Left     Expr[T]
	Operator token.Token
	Right    Expr[T]
}

type ExprUnary[T any] struct {
	Token token.Token
	Right Expr[T]
}

type ExprVariable[T any] struct {
	Name token.Token
}

type ExprVisitor[T any] interface {
	VisitorExprBinary(*ExprBinary[T]) T
	VisitorExprGrouping(*ExprGrouping[T]) T
	VisitorExprLiteral(*ExprLiteral[T]) T
	VisitorExprUnary(*ExprUnary[T]) T
	VisitorExprVariable(*ExprVariable[T]) T
	VisitorExprAssign(*ExprAssign[T]) T
	VisitorExprLogical(*ExprLogical[T]) T
	VisitorExprCall(*ExprCall[T]) T
}

type Stmt[T any] interface {
	Accept(v StmtVisitor[T]) T
}

type StmtBlock[T any] struct {
	Statements []Stmt[T]
}

type StmtExpr[T any] struct {
	Expression Expr[T]
}

type StmtFunction[T any] struct {
	Name   token.Token
	Params []token.Token
	Body   Stmt[T]
}

type StmtIf[T any] struct {
	Condition  Expr[T]
	ThenBranch Stmt[T]
	ElseBranch Stmt[T]
}

type StmtPrint[T any] struct {
	Expression Expr[T]
}

type StmtReturn[T any] struct {
	Keyword token.Token
	Value   Expr[T]
}

type StmtVar[T any] struct {
	Name        token.Token
	Initializer Expr[T]
}

type StmtVisitor[T any] interface {
	VisitorStmtPrint(*StmtPrint[T]) T
	VisitorStmtExpr(*StmtExpr[T]) T
	VisitorStmtVar(*StmtVar[T]) T
	VisitorStmtBlock(*StmtBlock[T]) T
	VisitorStmtIf(*StmtIf[T]) T
	VisitorStmtWhile(*StmtWhile[T]) T
	VisitorStmtFunction(*StmtFunction[T]) T
	VisitorStmtReturn(*StmtReturn[T]) T
}

type StmtWhile[T any] struct {
	Condition Expr[T]
	Body      Stmt[T]
}