style: moved functions around

pkg/saccharine/stringify.go

@@ -3,67 +3,65 @@ package saccharine
 import (
 	"fmt"
 	"strings"
-
-	"git.maximhutz.com/max/lambda/pkg/saccharine/ast"
 )
 
-func stringifyAtom(n *ast.Atom) string {
+func stringifyAtom(n *Atom) string {
 	return n.Name
 }
 
-func stringifyAbstraction(n *ast.Abstraction) string {
-	return "\\" + strings.Join(n.Parameters, " ") + "." + Stringify(n.Body)
+func stringifyAbstraction(n *Abstraction) string {
+	return "\\" + strings.Join(n.Parameters, " ") + "." + stringifyExpression(n.Body)
 }
 
-func stringifyApplication(n *ast.Application) string {
-	arguments := []string{Stringify(n.Abstraction)}
+func stringifyApplication(n *Application) string {
+	arguments := []string{stringifyExpression(n.Abstraction)}
 
 	for _, argument := range n.Arguments {
-		arguments = append(arguments, Stringify(argument))
+		arguments = append(arguments, stringifyExpression(argument))
 	}
 
 	return "(" + strings.Join(arguments, " ") + ")"
 }
 
-func stringifyLet(s *ast.LetStatement) string {
-	return s.Name + " " + strings.Join(s.Parameters, " ") + " := " + Stringify(s.Body)
+func stringifyLet(s *LetStatement) string {
+	return s.Name + " " + strings.Join(s.Parameters, " ") + " := " + stringifyExpression(s.Body)
 }
 
-func stringifyDeclare(s *ast.DeclareStatement) string {
-	return Stringify(s.Value)
+func stringifyDeclare(s *DeclareStatement) string {
+	return stringifyExpression(s.Value)
 }
 
-func stringifyStatement(s ast.Statement) string {
+func stringifyStatement(s Statement) string {
 	switch s := s.(type) {
-	case *ast.DeclareStatement:
+	case *DeclareStatement:
 		return stringifyDeclare(s)
-	case *ast.LetStatement:
+	case *LetStatement:
 		return stringifyLet(s)
 	default:
 		panic(fmt.Errorf("unknown statement type: %v", s))
 	}
 }
 
-func stringifyClause(n *ast.Clause) string {
+func stringifyClause(n *Clause) string {
 	stmts := ""
 
 	for _, statement := range n.Statements {
 		stmts += stringifyStatement(statement) + "; "
 	}
 
-	return "{ " + stmts + Stringify(n.Returns) + " }"
+	return "{ " + stmts + stringifyExpression(n.Returns) + " }"
 }
 
 // Convert an expression back into valid source code.
-func Stringify(n ast.Expression) string {
+func stringifyExpression(n Expression) string {
 	switch n := n.(type) {
-	case *ast.Atom:
+	case *Atom:
 		return stringifyAtom(n)
-	case *ast.Abstraction:
+	case *Abstraction:
 		return stringifyAbstraction(n)
-	case *ast.Application:
+	case *Application:
 		return stringifyApplication(n)
-	case *ast.Clause:
+	case *Clause:
 		return stringifyClause(n)
 	default:
 		panic(fmt.Errorf("unknown expression type: %T", n))