feat: fmt.Stringer

Closes #36

cmd/lambda/lambda.go

@@ -7,9 +7,7 @@ import (
 	"git.maximhutz.com/max/lambda/internal/config"
 	"git.maximhutz.com/max/lambda/internal/plugins"
 	"git.maximhutz.com/max/lambda/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/debruijn"
 	"git.maximhutz.com/max/lambda/pkg/lambda"
-	"git.maximhutz.com/max/lambda/pkg/reducer"
 	"git.maximhutz.com/max/lambda/pkg/saccharine"
 )
 
@@ -35,51 +33,35 @@ func main() {
 	compiled := convert.SaccharineToLambda(ast)
 	logger.Info("compiled λ expression", "tree", compiled.String())
 
-	// Create reducer based on the selected interpreter.
+	// Create reducer with the compiled expression.
-	var red reducer.Reducer
+	reducer := lambda.NewNormalOrderReducer(&compiled)
-	switch options.Interpreter {
-	case config.DeBruijnInterpreter:
-		dbExpr := convert.LambdaToDeBruijn(compiled)
-		logger.Info("converted to De Bruijn", "tree", dbExpr.String())
-		red = debruijn.NewNormalOrderReducer(&dbExpr)
-	default:
-		red = lambda.NewNormalOrderReducer(&compiled)
-	}
 
 	// If the user selected to track CPU performance, attach a profiler.
 	if options.Profile != "" {
-		plugins.NewPerformance(options.Profile, red)
+		plugins.NewPerformance(options.Profile, reducer)
 	}
 
 	// If the user selected to produce a step-by-step explanation, attach an
 	// observer.
 	if options.Explanation {
-		plugins.NewExplanation(red)
+		plugins.NewExplanation(reducer)
 	}
 
 	// If the user opted to track statistics, attach a tracker.
 	if options.Statistics {
-		plugins.NewStatistics(red)
+		plugins.NewStatistics(reducer)
 	}
 
 	// If the user selected for verbose debug logs, attach a reduction tracker.
 	if options.Verbose {
-		plugins.NewLogs(logger, red)
+		plugins.NewLogs(logger, reducer)
 	}
 
 	// Run reduction.
-	red.Reduce()
+	reducer.Reduce()
 
 	// Return the final reduced result.
-	// For De Bruijn, convert back to lambda for consistent output.
+	result := reducer.Expression().String()
-	var result string
-	if options.Interpreter == config.DeBruijnInterpreter {
-		dbExpr := red.Expression().(debruijn.Expression)
-		lambdaExpr := convert.DeBruijnToLambda(dbExpr)
-		result = lambdaExpr.String()
-	} else {
-		result = red.Expression().String()
-	}
 	err = options.Destination.Write(result)
 	cli.HandleError(err)
 }

cmd/lambda/lambda_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"git.maximhutz.com/max/lambda/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/debruijn"
 	"git.maximhutz.com/max/lambda/pkg/lambda"
 	"git.maximhutz.com/max/lambda/pkg/saccharine"
 	"github.com/stretchr/testify/assert"
@@ -37,36 +36,7 @@ func runSample(samplePath string) (string, error) {
 	return reducer.Expression().String() + "\n", nil
 }
 
-// Helper function to run a single sample through the De Bruijn interpreter.
+// Test that all samples produce expected output.
-func runSampleDeBruijn(samplePath string) (string, error) {
-	// Read the sample file.
-	input, err := os.ReadFile(samplePath)
-	if err != nil {
-		return "", err
-	}
-
-	// Parse code into syntax tree.
-	ast, err := saccharine.Parse(string(input))
-	if err != nil {
-		return "", err
-	}
-
-	// Compile expression to lambda calculus.
-	compiled := convert.SaccharineToLambda(ast)
-
-	// Convert to De Bruijn and run reducer.
-	dbExpr := convert.LambdaToDeBruijn(compiled)
-	reducer := debruijn.NewNormalOrderReducer(&dbExpr)
-	reducer.Reduce()
-
-	// Convert back to lambda for output.
-	result := reducer.Expression().(debruijn.Expression)
-	lambdaResult := convert.DeBruijnToLambda(result)
-
-	return lambdaResult.String() + "\n", nil
-}
-
-// Test that all samples produce expected output with lambda interpreter.
 func TestSamplesValidity(t *testing.T) {
 	// Discover all .test files in the tests directory.
 	testFiles, err := filepath.Glob("../../tests/*.test")
@@ -95,35 +65,6 @@ func TestSamplesValidity(t *testing.T) {
 	}
 }
 
-// Test that all samples produce expected output with De Bruijn interpreter.
-func TestSamplesValidityDeBruijn(t *testing.T) {
-	// Discover all .test files in the tests directory.
-	testFiles, err := filepath.Glob("../../tests/*.test")
-	assert.NoError(t, err, "Failed to read tests directory.")
-	assert.NotEmpty(t, testFiles, "No '*.test' files found in directory.")
-
-	for _, testPath := range testFiles {
-		// Build expected file path.
-		expectedPath := strings.TrimSuffix(testPath, filepath.Ext(testPath)) + ".expected"
-
-		name := strings.TrimSuffix(filepath.Base(testPath), filepath.Ext(testPath))
-
-		t.Run(name, func(t *testing.T) {
-			// Run the sample and capture output.
-			actual, err := runSampleDeBruijn(testPath)
-			assert.NoError(t, err, "Failed to run sample.")
-
-			// Read expected output.
-			expectedBytes, err := os.ReadFile(expectedPath)
-			assert.NoError(t, err, "Failed to read expected output.")
-			expected := string(expectedBytes)
-
-			// Compare outputs.
-			assert.Equal(t, expected, actual, "Output does not match expected.")
-		})
-	}
-}
-
 // Benchmark all samples using sub-benchmarks.
 func BenchmarkSamples(b *testing.B) {
 	// Discover all .test files in the tests directory.
@@ -142,22 +83,3 @@ func BenchmarkSamples(b *testing.B) {
 		})
 	}
 }
-
-// Benchmark all samples using De Bruijn interpreter.
-func BenchmarkSamplesDeBruijn(b *testing.B) {
-	// Discover all .test files in the tests directory.
-	testFiles, err := filepath.Glob("../../tests/*.test")
-	assert.NoError(b, err, "Failed to read tests directory.")
-	assert.NotEmpty(b, testFiles, "No '*.test' files found in directory.")
-
-	for _, path := range testFiles {
-		name := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
-
-		b.Run(name, func(b *testing.B) {
-			for b.Loop() {
-				_, err := runSampleDeBruijn(path)
-				assert.NoError(b, err, "Failed to run sample.")
-			}
-		})
-	}
-}

internal/config/config.go

@@ -1,14 +1,6 @@
 // Package "config" parses ad handles the user settings given to the program.
 package config
 
-// Interpreter specifies the reduction engine to use.
-type Interpreter string
-
-const (
-	LambdaInterpreter   Interpreter = "lambda"
-	DeBruijnInterpreter Interpreter = "debruijn"
-)
-
 // Configuration settings for the program.
 type Config struct {
 	Source      Source      // The source code given to the program.
@@ -17,5 +9,4 @@ type Config struct {
 	Explanation bool        // Whether or not to print an explanation of the reduction.
 	Profile     string      // If not nil, print a CPU profile during execution.
 	Statistics  bool        // Whether or not to print statistics.
-	Interpreter Interpreter // The interpreter engine to use.
 }

internal/config/parse_from_args.go

@@ -14,20 +14,8 @@ func FromArgs() (*Config, error) {
 	profile := flag.String("p", "", "CPU profiling. If an output file is defined, the program will profile its execution and dump its results into it.")
 	file := flag.String("f", "", "File. If set, read source from the specified file.")
 	output := flag.String("o", "", "Output. If set, write result to the specified file. Use '-' for stdout (default).")
-	interpreter := flag.String("i", "lambda", "Interpreter. The reduction engine to use: 'lambda' or 'debruijn'.")
 	flag.Parse()
 
-	// Validate interpreter flag.
-	var interpType Interpreter
-	switch *interpreter {
-	case "lambda":
-		interpType = LambdaInterpreter
-	case "debruijn":
-		interpType = DeBruijnInterpreter
-	default:
-		return nil, fmt.Errorf("invalid interpreter: %s (must be 'lambda' or 'debruijn')", *interpreter)
-	}
-
 	// Parse source type.
 	var source Source
 	if *file != "" {
@@ -64,6 +52,5 @@ func FromArgs() (*Config, error) {
 		Explanation: *explanation,
 		Profile:     *profile,
 		Statistics:  *statistics,
-		Interpreter: interpType,
 	}, nil
 }

pkg/convert/debruijn_to_lambda.go

@@ -1,82 +0,0 @@
-package convert
-
-import (
-	"fmt"
-
-	"git.maximhutz.com/max/lambda/pkg/debruijn"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-	"git.maximhutz.com/max/lambda/pkg/set"
-)
-
-// DeBruijnToLambda converts a De Bruijn indexed expression back to named lambda calculus.
-func DeBruijnToLambda(expr debruijn.Expression) lambda.Expression {
-	return deBruijnToLambdaWithContext(expr, []string{})
-}
-
-func deBruijnToLambdaWithContext(expr debruijn.Expression, context []string) lambda.Expression {
-	switch e := expr.(type) {
-	case *debruijn.Variable:
-		index := e.Index()
-		if index < len(context) {
-			// Bound variable: look up name in context.
-			name := context[len(context)-1-index]
-			return lambda.NewVariable(name)
-		}
-		// Free variable: use the label if available.
-		if e.Label() != "" {
-			return lambda.NewVariable(e.Label())
-		}
-		// Generate a name for free variables without labels.
-		return lambda.NewVariable(fmt.Sprintf("free%d", index))
-
-	case *debruijn.Abstraction:
-		// Generate a fresh parameter name.
-		used := collectUsedNames(e.Body(), context)
-		paramName := generateFreshName(used)
-		newContext := append(context, paramName)
-		body := deBruijnToLambdaWithContext(e.Body(), newContext)
-		return lambda.NewAbstraction(paramName, body)
-
-	case *debruijn.Application:
-		abs := deBruijnToLambdaWithContext(e.Abstraction(), context)
-		arg := deBruijnToLambdaWithContext(e.Argument(), context)
-		return lambda.NewApplication(abs, arg)
-
-	default:
-		panic("unknown expression type")
-	}
-}
-
-// collectUsedNames gathers all variable labels used in an expression.
-func collectUsedNames(expr debruijn.Expression, context []string) *set.Set[string] {
-	used := set.New[string]()
-	for _, name := range context {
-		used.Add(name)
-	}
-	collectUsedNamesHelper(expr, used)
-	return used
-}
-
-func collectUsedNamesHelper(expr debruijn.Expression, used *set.Set[string]) {
-	switch e := expr.(type) {
-	case *debruijn.Variable:
-		if e.Label() != "" {
-			used.Add(e.Label())
-		}
-	case *debruijn.Abstraction:
-		collectUsedNamesHelper(e.Body(), used)
-	case *debruijn.Application:
-		collectUsedNamesHelper(e.Abstraction(), used)
-		collectUsedNamesHelper(e.Argument(), used)
-	}
-}
-
-// generateFreshName creates a fresh variable name not in the used set.
-func generateFreshName(used *set.Set[string]) string {
-	for i := 0; ; i++ {
-		name := fmt.Sprintf("_%d", i)
-		if !used.Has(name) {
-			return name
-		}
-	}
-}

pkg/convert/lambda_to_debruijn.go

@@ -1,44 +0,0 @@
-package convert
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/debruijn"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-)
-
-// LambdaToDeBruijn converts a lambda calculus expression to De Bruijn indexed form.
-// The context parameter tracks bound variables from outer abstractions.
-func LambdaToDeBruijn(expr lambda.Expression) debruijn.Expression {
-	return lambdaToDeBruijnWithContext(expr, []string{})
-}
-
-func lambdaToDeBruijnWithContext(expr lambda.Expression, context []string) debruijn.Expression {
-	switch e := expr.(type) {
-	case *lambda.Variable:
-		name := e.Value()
-		// Search for the variable in the context (innermost to outermost).
-		for i := len(context) - 1; i >= 0; i-- {
-			if context[i] == name {
-				index := len(context) - 1 - i
-				return debruijn.NewVariable(index, name)
-			}
-		}
-		// Free variable: use a negative index to mark it.
-		// We encode free variables with index = len(context) + position.
-		// For simplicity, we use a large index that won't conflict.
-		return debruijn.NewVariable(len(context), name)
-
-	case *lambda.Abstraction:
-		// Add the parameter to the context.
-		newContext := append(context, e.Parameter())
-		body := lambdaToDeBruijnWithContext(e.Body(), newContext)
-		return debruijn.NewAbstraction(body)
-
-	case *lambda.Application:
-		abs := lambdaToDeBruijnWithContext(e.Abstraction(), context)
-		arg := lambdaToDeBruijnWithContext(e.Argument(), context)
-		return debruijn.NewApplication(abs, arg)
-
-	default:
-		panic("unknown expression type")
-	}
-}

pkg/debruijn/expression.go

@@ -1,119 +0,0 @@
-// Package debruijn provides De Bruijn indexed lambda calculus expressions.
-// De Bruijn indices eliminate the need for variable names by using numeric
-// indices to refer to bound variables, avoiding capture issues during substitution.
-package debruijn
-
-import "git.maximhutz.com/max/lambda/pkg/expr"
-
-// Expression is the interface for all De Bruijn indexed expression types.
-// It embeds the general expr.Expression interface for cross-mode compatibility.
-type Expression interface {
-	expr.Expression
-	Accept(Visitor)
-}
-
-/** ------------------------------------------------------------------------- */
-
-// Abstraction represents a lambda abstraction without a named parameter.
-// In De Bruijn notation, the parameter is implicit and referenced by index 0
-// within the body.
-type Abstraction struct {
-	body Expression
-}
-
-// Body returns the body of the abstraction.
-func (a *Abstraction) Body() Expression {
-	return a.body
-}
-
-// Accept implements the Visitor pattern.
-func (a *Abstraction) Accept(v Visitor) {
-	v.VisitAbstraction(a)
-}
-
-// String returns the De Bruijn notation string representation.
-func (a *Abstraction) String() string {
-	return Stringify(a)
-}
-
-// NewAbstraction creates a new De Bruijn abstraction with the given body.
-func NewAbstraction(body Expression) *Abstraction {
-	return &Abstraction{body: body}
-}
-
-/** ------------------------------------------------------------------------- */
-
-// Application represents the application of one expression to another.
-type Application struct {
-	abstraction Expression
-	argument    Expression
-}
-
-// Abstraction returns the function expression being applied.
-func (a *Application) Abstraction() Expression {
-	return a.abstraction
-}
-
-// Argument returns the argument expression.
-func (a *Application) Argument() Expression {
-	return a.argument
-}
-
-// Accept implements the Visitor pattern.
-func (a *Application) Accept(v Visitor) {
-	v.VisitApplication(a)
-}
-
-// String returns the De Bruijn notation string representation.
-func (a *Application) String() string {
-	return Stringify(a)
-}
-
-// NewApplication creates a new application expression.
-func NewApplication(abstraction Expression, argument Expression) *Application {
-	return &Application{abstraction: abstraction, argument: argument}
-}
-
-/** ------------------------------------------------------------------------- */
-
-// Variable represents a De Bruijn indexed variable.
-// The index indicates how many binders to skip to find the binding abstraction.
-// The label is an optional hint for display purposes.
-type Variable struct {
-	index int
-	label string
-}
-
-// Index returns the De Bruijn index.
-func (v *Variable) Index() int {
-	return v.index
-}
-
-// Label returns the optional variable label.
-func (v *Variable) Label() string {
-	return v.label
-}
-
-// Accept implements the Visitor pattern.
-func (v *Variable) Accept(visitor Visitor) {
-	visitor.VisitVariable(v)
-}
-
-// String returns the De Bruijn notation string representation.
-func (v *Variable) String() string {
-	return Stringify(v)
-}
-
-// NewVariable creates a new De Bruijn variable with the given index and label.
-func NewVariable(index int, label string) *Variable {
-	return &Variable{index: index, label: label}
-}
-
-/** ------------------------------------------------------------------------- */
-
-// Visitor interface for traversing De Bruijn expressions.
-type Visitor interface {
-	VisitAbstraction(*Abstraction)
-	VisitApplication(*Application)
-	VisitVariable(*Variable)
-}

pkg/debruijn/iterator.go

@@ -1,76 +0,0 @@
-package debruijn
-
-// Iterator provides depth-first traversal of De Bruijn expressions.
-type Iterator struct {
-	trace []*Expression
-}
-
-// NewIterator creates a new iterator starting at the given expression.
-func NewIterator(expr *Expression) *Iterator {
-	return &Iterator{[]*Expression{expr}}
-}
-
-// Done returns true when the iterator has finished traversal.
-func (i *Iterator) Done() bool {
-	return len(i.trace) == 0
-}
-
-// Current returns a pointer to the current expression.
-func (i *Iterator) Current() *Expression {
-	if i.Done() {
-		return nil
-	}
-
-	return i.trace[len(i.trace)-1]
-}
-
-// Parent returns a pointer to the parent expression.
-func (i *Iterator) Parent() *Expression {
-	if len(i.trace) < 2 {
-		return nil
-	}
-
-	return i.trace[len(i.trace)-2]
-}
-
-// Swap replaces the current expression with the given expression.
-func (i *Iterator) Swap(with Expression) {
-	current := i.Current()
-	if current != nil {
-		*current = with
-	}
-}
-
-// Back moves the iterator back to the parent expression.
-func (i *Iterator) Back() bool {
-	if i.Done() {
-		return false
-	}
-
-	i.trace = i.trace[:len(i.trace)-1]
-	return true
-}
-
-// Next advances the iterator to the next expression in leftmost-outermost order.
-func (i *Iterator) Next() {
-	switch typed := (*i.Current()).(type) {
-	case *Abstraction:
-		i.trace = append(i.trace, &typed.body)
-	case *Application:
-		i.trace = append(i.trace, &typed.abstraction)
-	case *Variable:
-		for len(i.trace) > 1 {
-			if app, ok := (*i.Parent()).(*Application); ok {
-				if app.abstraction == *i.Current() {
-					i.Back()
-					i.trace = append(i.trace, &app.argument)
-					return
-				}
-			}
-
-			i.Back()
-		}
-
-		i.trace = []*Expression{}
-	}
-}

pkg/debruijn/reducer.go

@@ -1,66 +0,0 @@
-package debruijn
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/emitter"
-	"git.maximhutz.com/max/lambda/pkg/expr"
-	"git.maximhutz.com/max/lambda/pkg/reducer"
-)
-
-// NormalOrderReducer implements normal order (leftmost-outermost) reduction
-// for De Bruijn indexed lambda calculus expressions.
-type NormalOrderReducer struct {
-	emitter.BaseEmitter[reducer.Event]
-	expression *Expression
-}
-
-// NewNormalOrderReducer creates a new normal order reducer.
-func NewNormalOrderReducer(expression *Expression) *NormalOrderReducer {
-	return &NormalOrderReducer{
-		BaseEmitter: *emitter.New[reducer.Event](),
-		expression:  expression,
-	}
-}
-
-// Expression returns the current expression state.
-func (r *NormalOrderReducer) Expression() expr.Expression {
-	return *r.expression
-}
-
-// isViable checks if an expression is a redex (reducible expression).
-// A redex is an application of an abstraction to an argument.
-func isViable(e *Expression) (*Abstraction, Expression, bool) {
-	if e == nil {
-		return nil, nil, false
-	} else if app, appOk := (*e).(*Application); !appOk {
-		return nil, nil, false
-	} else if fn, fnOk := app.abstraction.(*Abstraction); !fnOk {
-		return nil, nil, false
-	} else {
-		return fn, app.argument, true
-	}
-}
-
-// Reduce performs normal order reduction on a De Bruijn expression.
-func (r *NormalOrderReducer) Reduce() {
-	r.Emit(reducer.StartEvent)
-	it := NewIterator(r.expression)
-
-	for !it.Done() {
-		if fn, arg, ok := isViable(it.Current()); !ok {
-			it.Next()
-		} else {
-			// Substitute arg for variable 0 in the body.
-			substituted := Substitute(fn.body, 0, Shift(arg, 1, 0))
-			// Shift down to account for the removed abstraction.
-			it.Swap(Shift(substituted, -1, 0))
-
-			r.Emit(reducer.StepEvent)
-
-			if _, _, ok := isViable(it.Parent()); ok {
-				it.Back()
-			}
-		}
-	}
-
-	r.Emit(reducer.StopEvent)
-}

pkg/debruijn/shift.go

@@ -1,32 +0,0 @@
-package debruijn
-
-// Shift increments all free variable indices in an expression by the given amount.
-// A variable is free if its index is >= the cutoff (depth of nested abstractions).
-// This is necessary when substituting an expression into a different binding context.
-func Shift(expr Expression, amount int, cutoff int) Expression {
-	switch e := expr.(type) {
-	case *Variable:
-		if e.index >= cutoff {
-			return NewVariable(e.index+amount, e.label)
-		}
-		return e
-
-	case *Abstraction:
-		newBody := Shift(e.body, amount, cutoff+1)
-		if newBody == e.body {
-			return e
-		}
-		return NewAbstraction(newBody)
-
-	case *Application:
-		newAbs := Shift(e.abstraction, amount, cutoff)
-		newArg := Shift(e.argument, amount, cutoff)
-		if newAbs == e.abstraction && newArg == e.argument {
-			return e
-		}
-		return NewApplication(newAbs, newArg)
-
-	default:
-		return expr
-	}
-}

pkg/debruijn/stringify.go

@@ -1,35 +0,0 @@
-package debruijn
-
-import (
-	"strconv"
-	"strings"
-)
-
-type stringifyVisitor struct {
-	builder strings.Builder
-}
-
-func (v *stringifyVisitor) VisitVariable(a *Variable) {
-	v.builder.WriteString(strconv.Itoa(a.index))
-}
-
-func (v *stringifyVisitor) VisitAbstraction(f *Abstraction) {
-	v.builder.WriteRune('\\')
-	v.builder.WriteRune('.')
-	f.body.Accept(v)
-}
-
-func (v *stringifyVisitor) VisitApplication(c *Application) {
-	v.builder.WriteRune('(')
-	c.abstraction.Accept(v)
-	v.builder.WriteRune(' ')
-	c.argument.Accept(v)
-	v.builder.WriteRune(')')
-}
-
-// Stringify converts a De Bruijn expression to its string representation.
-func Stringify(e Expression) string {
-	b := &stringifyVisitor{builder: strings.Builder{}}
-	e.Accept(b)
-	return b.builder.String()
-}

pkg/debruijn/substitute.go

@@ -1,34 +0,0 @@
-package debruijn
-
-// Substitute replaces the variable at the given index with the replacement expression.
-// The replacement is shifted appropriately as we descend into nested abstractions.
-func Substitute(expr Expression, index int, replacement Expression) Expression {
-	switch e := expr.(type) {
-	case *Variable:
-		if e.index == index {
-			return replacement
-		}
-		return e
-
-	case *Abstraction:
-		// When entering an abstraction, increment the target index and shift the
-		// replacement to account for the new binding context.
-		shiftedReplacement := Shift(replacement, 1, 0)
-		newBody := Substitute(e.body, index+1, shiftedReplacement)
-		if newBody == e.body {
-			return e
-		}
-		return NewAbstraction(newBody)
-
-	case *Application:
-		newAbs := Substitute(e.abstraction, index, replacement)
-		newArg := Substitute(e.argument, index, replacement)
-		if newAbs == e.abstraction && newArg == e.argument {
-			return e
-		}
-		return NewApplication(newAbs, newArg)
-
-	default:
-		return expr
-	}
-}

pkg/deltanet/deltanet.go

@@ -1,6 +0,0 @@
-// Package "deltanet" is a reduction strategy using ∆-nets.
-package deltanet
-
-type Graph struct {
-	Nodes []Node
-}

pkg/deltanet/node.go

@@ -1,94 +0,0 @@
-package deltanet
-
-/** ------------------------------------------------------------------------- */
-
-// A connection between exactly two nodes in a graph.
-type Edge struct {
-	A, B Node
-}
-
-// Returns all nodes the edge is connected to.
-func (e Edge) GetConnections() []Node { return []Node{e.A, e.B} }
-
-// Determines if a node is connected via this edge.
-func (e Edge) IsConnected(n Node) bool { return e.A == n || e.B == n }
-
-// Swaps an edges connected with one node, for another.
-func (e *Edge) Swap(from Node, to Node) {
-	if e.A == from {
-		e.A = to
-	}
-	if e.B == from {
-		e.B = to
-	}
-}
-
-// Returns true if the edge is connected to each node via their pricniple ports.
-func (e Edge) IsPrincipleEdge() bool {
-	return e.A.GetMainPort() == e && e.B.GetMainPort() == e
-}
-
-/** ------------------------------------------------------------------------- */
-
-type Node interface {
-	// Returns the principle port that the node is attached to.
-	GetMainPort() Edge
-
-	// Returns all auxiliary ports that the node has. These ports are guaranteed
-	// to be ordered clockwise, as they would appear graphically.
-	GetAuxPorts() []Edge
-
-	// Returns the label of the node. May be blank.
-	GetLabel() string
-}
-
-/** ------------------------------------------------------------------------- */
-
-type EraserNode struct {
-	Main Edge
-}
-
-func (n EraserNode) GetLabel() string    { return "Ⓧ" }
-func (n EraserNode) GetMainPort() Edge   { return n.Main }
-func (n EraserNode) GetAuxPorts() []Edge { return []Edge{} }
-
-/** ------------------------------------------------------------------------- */
-
-type ReplicatorNode struct {
-	Main   Edge
-	Level  uint
-	Aux    []Edge
-	Deltas []int
-}
-
-func (n ReplicatorNode) GetLabel() string    { return "" }
-func (n ReplicatorNode) GetMainPort() Edge   { return n.Main }
-func (n ReplicatorNode) GetAuxPorts() []Edge { return n.Aux }
-
-// Returns the level of the replicator node.
-func (n ReplicatorNode) GetLevel() uint { return n.Level }
-
-/** ------------------------------------------------------------------------- */
-
-type FanNode struct {
-	Label       string
-	Main        Edge
-	Left, Right Edge
-}
-
-func (n FanNode) GetLabel() string    { return n.Label }
-func (n FanNode) GetMainPort() Edge   { return n.Main }
-func (n FanNode) GetAuxPorts() []Edge { return []Edge{n.Left, n.Right} }
-
-/** ------------------------------------------------------------------------- */
-
-type TerminalNode struct {
-	Label string
-	Main  Edge
-}
-
-func (n TerminalNode) GetLabel() string    { return n.Label }
-func (n TerminalNode) GetMainPort() Edge   { return n.Main }
-func (n TerminalNode) GetAuxPorts() []Edge { return []Edge{} }
-
-/** ------------------------------------------------------------------------- */

pkg/expr/expr.go

@@ -2,10 +2,14 @@
 // expression types in the lambda interpreter.
 package expr
 
+import (
+	"fmt"
+)
+
 // Expression is the base interface for all evaluatable expression types.
 // Different evaluation modes (lambda calculus, SKI combinators, typed lambda
 // calculus, etc.) implement this interface with their own concrete types.
 type Expression interface {
-	// String returns a human-readable representation of the expression.
+	// The expression should have a human-readable representation.
-	String() string
+	fmt.Stringer
 }

pkg/lambda/expression.go

@@ -1,12 +1,13 @@
 package lambda
 
-import "git.maximhutz.com/max/lambda/pkg/expr"
+import (
+	"git.maximhutz.com/max/lambda/pkg/expr"
+)
 
 // Expression is the interface for all lambda calculus expression types.
 // It embeds the general expr.Expression interface for cross-mode compatibility.
 type Expression interface {
 	expr.Expression
-	Accept(Visitor)
 }
 
 /** ------------------------------------------------------------------------- */
@@ -16,6 +17,8 @@ type Abstraction struct {
 	body      Expression
 }
 
+var _ Expression = (*Abstraction)(nil)
+
 func (a *Abstraction) Parameter() string {
 	return a.parameter
 }
@@ -24,16 +27,12 @@ func (a *Abstraction) Body() Expression {
 	return a.body
 }
 
-func (a *Abstraction) Accept(v Visitor) {
-	v.VisitAbstraction(a)
-}
-
 func (a *Abstraction) String() string {
-	return Stringify(a)
+	return "\\" + a.parameter + "." + a.body.String()
 }
 
 func NewAbstraction(parameter string, body Expression) *Abstraction {
-	return &Abstraction{parameter: parameter, body: body}
+	return &Abstraction{parameter, body}
 }
 
 /** ------------------------------------------------------------------------- */
@@ -43,6 +42,8 @@ type Application struct {
 	argument    Expression
 }
 
+var _ Expression = (*Application)(nil)
+
 func (a *Application) Abstraction() Expression {
 	return a.abstraction
 }
@@ -51,16 +52,12 @@ func (a *Application) Argument() Expression {
 	return a.argument
 }
 
-func (a *Application) Accept(v Visitor) {
-	v.VisitApplication(a)
-}
-
 func (a *Application) String() string {
-	return Stringify(a)
+	return "(" + a.abstraction.String() + " " + a.argument.String() + ")"
 }
 
 func NewApplication(abstraction Expression, argument Expression) *Application {
-	return &Application{abstraction: abstraction, argument: argument}
+	return &Application{abstraction, argument}
 }
 
 /** ------------------------------------------------------------------------- */
@@ -69,26 +66,16 @@ type Variable struct {
 	value string
 }
 
+var _ Expression = (*Variable)(nil)
+
 func (v *Variable) Value() string {
 	return v.value
 }
 
-func (v *Variable) Accept(visitor Visitor) {
-	visitor.VisitVariable(v)
-}
-
 func (v *Variable) String() string {
-	return Stringify(v)
+	return v.value
 }
 
 func NewVariable(name string) *Variable {
-	return &Variable{value: name}
+	return &Variable{name}
-}
-
-/** ------------------------------------------------------------------------- */
-
-type Visitor interface {
-	VisitAbstraction(*Abstraction)
-	VisitApplication(*Application)
-	VisitVariable(*Variable)
 }

pkg/lambda/stringify.go

@@ -1,32 +0,0 @@
-package lambda
-
-import "strings"
-
-type stringifyVisitor struct {
-	builder strings.Builder
-}
-
-func (v *stringifyVisitor) VisitVariable(a *Variable) {
-	v.builder.WriteString(a.value)
-}
-
-func (v *stringifyVisitor) VisitAbstraction(f *Abstraction) {
-	v.builder.WriteRune('\\')
-	v.builder.WriteString(f.parameter)
-	v.builder.WriteRune('.')
-	f.body.Accept(v)
-}
-
-func (v *stringifyVisitor) VisitApplication(c *Application) {
-	v.builder.WriteRune('(')
-	c.abstraction.Accept(v)
-	v.builder.WriteRune(' ')
-	c.argument.Accept(v)
-	v.builder.WriteRune(')')
-}
-
-func Stringify(e Expression) string {
-	b := &stringifyVisitor{builder: strings.Builder{}}
-	e.Accept(b)
-	return b.builder.String()
-}