feat: better recursive descent

pkg/saccharine/ast/node.go

@@ -0,0 +1,41 @@
+package ast
+
+type Expression interface {
+	IsExpression()
+}
+
+/** ------------------------------------------------------------------------- */
+
+type Abstraction struct {
+	Parameters []string
+	Body       Expression
+}
+
+type Application struct {
+	Abstraction Expression
+	Arguments   []Expression
+}
+
+type Atom struct {
+	Name string
+}
+
+/** ------------------------------------------------------------------------- */
+
+func NewAbstraction(parameter []string, body Expression) *Abstraction {
+	return &Abstraction{Parameters: parameter, Body: body}
+}
+
+func NewApplication(abstraction Expression, arguments []Expression) *Application {
+	return &Application{Abstraction: abstraction, Arguments: arguments}
+}
+
+func NewAtom(name string) *Atom {
+	return &Atom{Name: name}
+}
+
+/** ------------------------------------------------------------------------- */
+
+func (a Abstraction) IsExpression() {}
+func (a Application) IsExpression() {}
+func (v Atom) IsExpression()        {}

pkg/saccharine/ast/visit.go

@@ -0,0 +1,22 @@
+package ast
+
+import "fmt"
+
+type Visitor[T any] interface {
+	VisitAtom(*Atom) T
+	VisitAbstraction(*Abstraction) T
+	VisitApplication(*Application) T
+}
+
+func Visit[T any](visitor Visitor[T], node Expression) T {
+	switch node := node.(type) {
+	case *Atom:
+		return visitor.VisitAtom(node)
+	case *Abstraction:
+		return visitor.VisitAbstraction(node)
+	case *Application:
+		return visitor.VisitApplication(node)
+	default:
+		panic(fmt.Sprintf("unknown node %t", node))
+	}
+}