feat: copied code over

pkg/repr/saccharine/stringify.go

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