feat: progress

Add a new interpreter option (-i debruijn) that uses De Bruijn indices
for variable representation, eliminating the need for variable renaming
during substitution.

- Add -i flag to select interpreter (lambda or debruijn)
- Create debruijn package with Expression types (Variable with index,
  Abstraction without parameter, Application)
- Implement shift and substitute operations for De Bruijn indices
- Add conversion functions between lambda and De Bruijn representations
- Update CLI to support switching between interpreters
- Add De Bruijn tests to verify all samples pass

Closes #26

.gitea/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,58 @@
+---
+name: "Bug Report"
+about: "Report a bug or unexpected behavior in the lambda interpreter."
+title: "fix: "
+ref: "main"
+assignees: []
+labels:
+  - bug
+---
+
+## Context
+
+<!--
+Describe what you were trying to do when you encountered the bug.
+Explain what you expected to happen.
+-->
+
+## Current Behavior
+
+<!--
+Describe what actually happened.
+Be specific about the incorrect behavior or error.
+-->
+
+## Steps to Reproduce
+
+<!--
+Provide step-by-step instructions to reproduce the issue.
+Include any relevant code, commands, or input.
+-->
+
+1.
+2.
+3.
+
+## Expected Behavior
+
+<!--
+Describe what should happen instead.
+-->
+
+## Environment
+
+<!--
+Provide relevant information about your environment.
+-->
+
+- Lambda version:
+- Go version:
+- Operating system:
+
+## Additional Context
+
+<!--
+Add any other context about the problem.
+Include error messages, logs, or screenshots if applicable.
+If none exist, omit this section.
+-->

.gitea/ISSUE_TEMPLATE/feature.md

@@ -0,0 +1,44 @@
+---
+name: "Feature Request"
+about: "Suggest a new feature or enhancement for the lambda interpreter."
+title: "feat: "
+ref: "main"
+assignees: []
+labels:
+  - enhancement
+---
+
+## Context
+
+<!--
+Describe the problem or limitation you're encountering.
+Explain why this feature would be valuable.
+-->
+
+## Proposed Solution
+
+<!--
+Describe your proposed solution or enhancement.
+Be specific about what you want to see implemented.
+-->
+
+## Alternatives Considered
+
+<!--
+List any alternative solutions or approaches you've considered.
+If none exist, omit this section.
+-->
+
+## Acceptance Criteria
+
+<!--
+List clear, testable criteria that define when this feature is complete.
+Use bullet points starting with •
+-->
+
+## Additional Context
+
+<!--
+Add any other context, screenshots, or examples about the feature request.
+If none exist, omit this section.
+-->

.gitea/ISSUE_TEMPLATE/general.md

@@ -0,0 +1,37 @@
+---
+name: "General Issue"
+about: "Create an issue that doesn't fit other templates."
+title: ""
+ref: "main"
+assignees: []
+labels: []
+---
+
+## Context
+
+<!--
+Describe the background and context for this issue.
+Explain why this issue exists.
+-->
+
+## Description
+
+<!--
+Provide a detailed description of what needs to be done.
+Be clear and specific about the requirements.
+-->
+
+## Acceptance Criteria
+
+<!--
+List clear, testable criteria that define when this issue is complete.
+Use bullet points starting with •
+If none exist, omit this section.
+-->
+
+## Additional Context
+
+<!--
+Add any other relevant information, links, or references.
+If none exist, omit this section.
+-->

.gitignore

@@ -10,9 +10,6 @@
 *.so
 *.dylib
 
-# Test binary, built with `go test -c`
-*.test
-
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 

CLAUDE.md

@@ -37,6 +37,31 @@ Use format: `<type>/<description>` with kebab-case.
 
 DO NOT advertise Claude.
 
+## Issue Management
+
+Use the `tea` CLI (Gitea command-line tool) for issue operations.
+
+**Common commands**:
+
+- `tea issues list` - List all issues.
+- `tea issues <number>` - View details of a specific issue.
+- `tea issues create --title "<title>" --body "<description>"` - Create a new issue.
+- `tea issues close <number>` - Close an issue.
+
+**Reading issues**: Use `tea issues <number>` to read the full details of an issue before starting work.
+
+## Issue Workflow
+
+When working on an issue:
+
+1. Read the issue using `tea issues <number>` to understand requirements.
+2. Create a feature branch following the branch naming convention.
+3. Make commits following the conventional commit format.
+4. Submit a pull request when ready.
+
+**Important**: Never commit directly to `main`.
+All work must be done in a feature branch and submitted via pull request.
+
 ## Pull Request Management
 
 Use the `tea` CLI (Gitea command-line tool) for PR operations instead of `gh`.
@@ -52,3 +77,29 @@ Use the `tea` CLI (Gitea command-line tool) for PR operations instead of `gh`.
 **Note**: Use `--description` (not `--body`) for PR body content.
 
 **Creating PRs**: Always create PRs in a branch other than `main`, to the `main` branch unless specified otherwise. ALWAYS FOLLOW THE PR TEMPLATE, EXACTLY.
+
+**Linking issues**: When a PR solves an issue, reference the issue in both the commit message and PR description using `Closes #<number>`.
+This automatically links and closes the issue when the PR is merged.
+
+### Updating PRs
+
+When pushing additional changes to an existing PR, add a comment summarizing the new commits.
+This keeps reviewers informed of what changed since the initial PR description.
+
+Use the `tea` CLI to add comments to pull requests:
+
+```bash
+tea comment <number> "Comment text"
+```
+
+#### Examples
+
+```bash
+# Add a comment to PR #42
+tea comment 42 "Updated implementation based on feedback"
+
+# Add a multi-line comment
+tea comment 42 "Summary of changes:
+- Fixed bug in reducer
+- Added new tests"
+```

Makefile

@@ -1,7 +1,7 @@
 BINARY_NAME=lambda
 TEST=simple
 
-.PHONY: help build run profile explain graph docs bench clean
+.PHONY: help build run profile explain graph docs test bench clean
 .DEFAULT_GOAL := help
 .SILENT:
 
@@ -13,6 +13,7 @@ help:
 	echo "  explain  - Build and run with explanation mode and profiling"
 	echo "  graph    - Generate and open CPU profile visualization"
 	echo "  docs     - Start local godoc server on port 6060"
+	echo "  test     - Run tests for all samples"
 	echo "  bench    - Run benchmarks for all samples"
 	echo "  clean    - Remove all build artifacts"
 
@@ -21,13 +22,13 @@ build:
 	chmod +x ${BINARY_NAME}
 
 run: build
-	./${BINARY_NAME} -s -f ./samples/$(TEST).txt -o program.out
+	./${BINARY_NAME} -s -f ./tests/$(TEST).test -o program.out
 
 profile: build
-	./${BINARY_NAME} -p profile/cpu.prof -f ./samples/$(TEST).txt -o program.out
+	./${BINARY_NAME} -p profile/cpu.prof -f ./tests/$(TEST).test -o program.out
 
 explain: build
-	./${BINARY_NAME} -x -p profile/cpu.prof -f ./samples/$(TEST).txt -o program.out
+	./${BINARY_NAME} -x -p profile/cpu.prof -f ./tests/$(TEST).test -o program.out > explain.out
 
 graph:
 	go tool pprof -raw -output=profile/cpu.raw profile/cpu.prof
@@ -38,6 +39,9 @@ docs:
 	echo ">>> View at 'http://localhost:6060/pkg/git.maximhutz.com/max/lambda/'"
 	go run golang.org/x/tools/cmd/godoc@latest -http=:6060
 
+test:
+	go test -v ./cmd/lambda
+
 bench:
 	go test -bench=. -benchtime=10x -cpu=4 ./cmd/lambda
 

cmd/lambda/benchmark_test.go

@@ -1,70 +0,0 @@
-package main
-
-import (
-	"os"
-	"testing"
-
-	"git.maximhutz.com/max/lambda/internal/config"
-	"git.maximhutz.com/max/lambda/internal/engine"
-	"git.maximhutz.com/max/lambda/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-	"git.maximhutz.com/max/lambda/pkg/saccharine"
-)
-
-// Helper function to run a single sample through the lambda interpreter.
-func runSample(samplePath 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)
-
-	// Create minimal config for benchmarking.
-	cfg := &config.Config{
-		Source:      config.StringSource{Data: ""},
-		Destination: config.StdoutDestination{},
-		Profile:     "",
-		Explanation: false,
-		Statistics:  false,
-		Verbose:     false,
-	}
-
-	// Create and run the engine.
-	process := engine.New(cfg, &compiled)
-	process.Run()
-
-	// Get final result (to ensure it's not optimized away).
-	_ = lambda.Stringify(compiled)
-
-	return nil
-}
-
-// Benchmark all samples using sub-benchmarks.
-func BenchmarkSamples(b *testing.B) {
-	samples := map[string]string{
-		"Church":     "../../samples/church.test",
-		"Fast":       "../../samples/fast.test",
-		"Saccharine": "../../samples/saccharine.test",
-		"Simple":     "../../samples/simple.test",
-		"Thunk":      "../../samples/thunk.test",
-	}
-
-	for name, path := range samples {
-		b.Run(name, func(b *testing.B) {
-			for b.Loop() {
-				if err := runSample(path); err != nil {
-					b.Fatal(err)
-				}
-			}
-		})
-	}
-}

cmd/lambda/lambda.go

@@ -5,12 +5,11 @@ import (
 
 	"git.maximhutz.com/max/lambda/internal/cli"
 	"git.maximhutz.com/max/lambda/internal/config"
-	"git.maximhutz.com/max/lambda/internal/engine"
-	"git.maximhutz.com/max/lambda/internal/explanation"
-	"git.maximhutz.com/max/lambda/internal/performance"
-	"git.maximhutz.com/max/lambda/internal/statistics"
+	"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"
 )
 
@@ -34,44 +33,53 @@ func main() {
 
 	// Compile expression to lambda calculus.
 	compiled := convert.SaccharineToLambda(ast)
-	logger.Info("compiled λ expression", "tree", lambda.Stringify(compiled))
+	logger.Info("compiled λ expression", "tree", compiled.String())
 
-	// Create reduction engine.
-	process := engine.New(options, &compiled)
+	// Create reducer based on the selected interpreter.
+	var red reducer.Reducer
+	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 to the
-	// process.
+	// If the user selected to track CPU performance, attach a profiler.
 	if options.Profile != "" {
-		profiler := performance.Track(options.Profile)
-		process.On("start", profiler.Start)
-		process.On("end", profiler.End)
+		plugins.NewPerformance(options.Profile, red)
 	}
 
 	// If the user selected to produce a step-by-step explanation, attach an
-	// observer here.
+	// observer.
 	if options.Explanation {
-		explanation.Track(process)
+		plugins.NewExplanation(red)
 	}
 
-	// If the user opted to track statistics, attach a tracker here, too.
+	// If the user opted to track statistics, attach a tracker.
 	if options.Statistics {
-		statistics := statistics.Track()
-		process.On("start", statistics.Start)
-		process.On("step", statistics.Step)
-		process.On("end", statistics.End)
+		plugins.NewStatistics(red)
 	}
 
 	// If the user selected for verbose debug logs, attach a reduction tracker.
 	if options.Verbose {
-		process.On("step", func() {
-			logger.Info("reduction", "tree", lambda.Stringify(compiled))
-		})
+		plugins.NewLogs(logger, red)
 	}
 
-	process.Run()
+	// Run reduction.
+	red.Reduce()
 
 	// Return the final reduced result.
-	result := lambda.Stringify(compiled)
+	// For De Bruijn, convert back to lambda for consistent output.
+	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

@@ -0,0 +1,163 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"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"
+)
+
+// Helper function to run a single sample through the lambda interpreter.
+func runSample(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)
+
+	// Create and run the reducer.
+	reducer := lambda.NewNormalOrderReducer(&compiled)
+	reducer.Reduce()
+
+	return reducer.Expression().String() + "\n", nil
+}
+
+// Helper function to run a single sample through the De Bruijn interpreter.
+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")
+	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 := runSample(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.")
+		})
+	}
+}
+
+// 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.
+	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 := runSample(path)
+				assert.NoError(b, err, "Failed to run sample.")
+			}
+		})
+	}
+}
+
+// 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.")
+			}
+		})
+	}
+}

go.mod

@@ -1,3 +1,11 @@
 module git.maximhutz.com/max/lambda
 
 go 1.25.5
+
+require github.com/stretchr/testify v1.11.1
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,9 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/config/config.go

@@ -1,6 +1,14 @@
 // 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.
@@ -9,4 +17,5 @@ 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,8 +14,20 @@ 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 != "" {
@@ -52,5 +64,6 @@ func FromArgs() (*Config, error) {
 		Explanation: *explanation,
 		Profile:     *profile,
 		Statistics:  *statistics,
+		Interpreter: interpType,
 	}, nil
 }

internal/engine/engine.go

@@ -1,32 +0,0 @@
-// Package "engine" provides an extensible interface for users to interfact with
-// λ-calculus.
-package engine
-
-import (
-	"git.maximhutz.com/max/lambda/internal/config"
-	"git.maximhutz.com/max/lambda/pkg/emitter"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-)
-
-// A process for reducing one λ-expression.
-type Engine struct {
-	Config     *config.Config
-	Expression *lambda.Expression
-	emitter.Emitter
-}
-
-// Create a new engine, given an unreduced λ-expression.
-func New(config *config.Config, expression *lambda.Expression) *Engine {
-	return &Engine{Config: config, Expression: expression}
-}
-
-// Begin the reduction process.
-func (e Engine) Run() {
-	e.Emit("start")
-
-	lambda.ReduceAll(e.Expression, func() {
-		e.Emit("step")
-	})
-
-	e.Emit("end")
-}

internal/explanation/tracker.go

@@ -1,32 +0,0 @@
-// Package "explanation" provides a observer to gather the reasoning during the
-// reduction, and present a thorough explanation to the user for each step.
-package explanation
-
-import (
-	"fmt"
-
-	"git.maximhutz.com/max/lambda/internal/engine"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-)
-
-// Track the reductions made by a reduction proess.
-type Tracker struct {
-	process *engine.Engine
-}
-
-// Attaches a new explanation tracker to a process.
-func Track(process *engine.Engine) *Tracker {
-	tracker := &Tracker{process: process}
-	process.On("start", tracker.Start)
-	process.On("step", tracker.Step)
-
-	return tracker
-}
-
-func (t *Tracker) Start() {
-	fmt.Println(lambda.Stringify(*t.process.Expression))
-}
-
-func (t *Tracker) Step() {
-	fmt.Println("    =", lambda.Stringify(*t.process.Expression))
-}

internal/plugins/debug.go

@@ -0,0 +1,23 @@
+package plugins
+
+import (
+	"log/slog"
+
+	"git.maximhutz.com/max/lambda/pkg/reducer"
+)
+
+type Logs struct {
+	logger  *slog.Logger
+	reducer reducer.Reducer
+}
+
+func NewLogs(logger *slog.Logger, r reducer.Reducer) *Logs {
+	plugin := &Logs{logger, r}
+	r.On(reducer.StepEvent, plugin.Step)
+
+	return plugin
+}
+
+func (t *Logs) Step() {
+	t.logger.Info("reduction", "tree", t.reducer.Expression().String())
+}

internal/plugins/explanation.go

@@ -0,0 +1,31 @@
+// Package "explanation" provides an observer to gather the reasoning during the
+// reduction, and present a thorough explanation to the user for each step.
+package plugins
+
+import (
+	"fmt"
+
+	"git.maximhutz.com/max/lambda/pkg/reducer"
+)
+
+// Track the reductions made by a reduction process.
+type Explanation struct {
+	reducer reducer.Reducer
+}
+
+// Attaches a new explanation tracker to a reducer.
+func NewExplanation(r reducer.Reducer) *Explanation {
+	plugin := &Explanation{reducer: r}
+	r.On(reducer.StartEvent, plugin.Start)
+	r.On(reducer.StepEvent, plugin.Step)
+
+	return plugin
+}
+
+func (t *Explanation) Start() {
+	fmt.Println(t.reducer.Expression().String())
+}
+
+func (t *Explanation) Step() {
+	fmt.Println("    =", t.reducer.Expression().String())
+}

internal/plugins/performance.go

@@ -1,28 +1,34 @@
 // Package "performance" provides a tracker to observer CPU performance during
 // execution.
-package performance
+package plugins
 
 import (
 	"os"
 	"path/filepath"
 	"runtime/pprof"
+
+	"git.maximhutz.com/max/lambda/pkg/reducer"
 )
 
 // Observes a reduction process, and publishes a CPU performance profile on
 // completion.
-type Tracker struct {
+type Performance struct {
 	File        string
 	filePointer *os.File
 	Error       error
 }
 
 // Create a performance tracker that outputs a profile to "file".
-func Track(file string) *Tracker {
-	return &Tracker{File: file}
+func NewPerformance(file string, process reducer.Reducer) *Performance {
+	plugin := &Performance{File: file}
+	process.On(reducer.StartEvent, plugin.Start)
+	process.On(reducer.StopEvent, plugin.Stop)
+
+	return plugin
 }
 
 // Begin profiling.
-func (t *Tracker) Start() {
+func (t *Performance) Start() {
 	var absPath string
 
 	absPath, t.Error = filepath.Abs(t.File)
@@ -47,7 +53,7 @@ func (t *Tracker) Start() {
 }
 
 // Stop profiling.
-func (t *Tracker) End() {
+func (t *Performance) Stop() {
 	pprof.StopCPUProfile()
 	t.filePointer.Close()
 }

internal/plugins/statistics.go

@@ -0,0 +1,44 @@
+package plugins
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"git.maximhutz.com/max/lambda/internal/statistics"
+	"git.maximhutz.com/max/lambda/pkg/reducer"
+)
+
+// An observer, to track reduction performance.
+type Statistics struct {
+	start time.Time
+	steps uint64
+}
+
+// Create a new reduction performance Statistics.
+func NewStatistics(r reducer.Reducer) *Statistics {
+	plugin := &Statistics{}
+	r.On(reducer.StartEvent, plugin.Start)
+	r.On(reducer.StepEvent, plugin.Step)
+	r.On(reducer.StopEvent, plugin.Stop)
+
+	return plugin
+}
+
+func (t *Statistics) Start() {
+	t.start = time.Now()
+	t.steps = 0
+}
+
+func (t *Statistics) Step() {
+	t.steps++
+}
+
+func (t *Statistics) Stop() {
+	results := statistics.Results{
+		StepsTaken:  t.steps,
+		TimeElapsed: uint64(time.Since(t.start).Milliseconds()),
+	}
+
+	fmt.Fprint(os.Stderr, results.String())
+}

internal/statistics/tracker.go

@@ -1,36 +0,0 @@
-package statistics
-
-import (
-	"fmt"
-	"os"
-	"time"
-)
-
-// An observer, to track reduction performance.
-type Tracker struct {
-	start time.Time
-	steps uint64
-}
-
-// Create a new reduction performance tracker.
-func Track() *Tracker {
-	return &Tracker{}
-}
-
-func (t *Tracker) Start() {
-	t.start = time.Now()
-	t.steps = 0
-}
-
-func (t *Tracker) Step() {
-	t.steps++
-}
-
-func (t *Tracker) End() {
-	results := Results{
-		StepsTaken:  t.steps,
-		TimeElapsed: uint64(time.Since(t.start).Milliseconds()),
-	}
-
-	fmt.Fprint(os.Stderr, results.String())
-}

pkg/convert/debruijn_to_lambda.go

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,119 @@
+// 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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,34 @@
+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/emitter/emitter.go

@@ -2,53 +2,45 @@ package emitter
 
 import "git.maximhutz.com/max/lambda/pkg/set"
 
-type Observer struct {
-	fn      func()
-	message string
-	emitter *Emitter
+type Emitter[E comparable] interface {
+	On(E, func()) Listener[E]
+	Off(Listener[E])
+	Emit(E)
 }
 
-type Emitter struct {
-	listeners map[string]*set.Set[*Observer]
+type BaseEmitter[E comparable] struct {
+	listeners map[E]*set.Set[Listener[E]]
 }
 
-func Ignore[T any](fn func()) func(T) {
-	return func(T) { fn() }
+func (e *BaseEmitter[E]) On(kind E, fn func()) Listener[E] {
+	if e.listeners[kind] == nil {
+		e.listeners[kind] = set.New[Listener[E]]()
 	}
 
-func (e *Emitter) On(message string, fn func()) *Observer {
-	observer := &Observer{
-		fn:      fn,
-		message: message,
-		emitter: e,
+	listener := &BaseListener[E]{kind, fn}
+	e.listeners[kind].Add(listener)
+	return listener
 }
 
-	if e.listeners == nil {
-		e.listeners = map[string]*set.Set[*Observer]{}
+func (e *BaseEmitter[E]) Off(listener Listener[E]) {
+	kind := listener.Kind()
+	if e.listeners[kind] != nil {
+		e.listeners[kind].Remove(listener)
+	}
 }
 
-	if e.listeners[message] == nil {
-		e.listeners[message] = set.New[*Observer]()
+func (e *BaseEmitter[E]) Emit(event E) {
+	if e.listeners[event] == nil {
+		e.listeners[event] = set.New[Listener[E]]()
 	}
 
-	e.listeners[message].Add(observer)
-	return observer
+	for listener := range e.listeners[event].Items() {
+		listener.Run()
+	}
 }
 
-func (o *Observer) Off() {
-	if o.emitter.listeners[o.message] == nil {
-		return
-	}
-
-	o.emitter.listeners[o.message].Remove(o)
-}
-
-func (e *Emitter) Emit(message string) {
-	if e.listeners[message] == nil {
-		return
-	}
-
-	for listener := range *e.listeners[message] {
-		listener.fn()
+func New[E comparable]() *BaseEmitter[E] {
+	return &BaseEmitter[E]{
+		listeners: map[E]*set.Set[Listener[E]]{},
 	}
 }

pkg/emitter/listener.go

@@ -0,0 +1,19 @@
+package emitter
+
+type Listener[E comparable] interface {
+	Kind() E
+	Run()
+}
+
+type BaseListener[E comparable] struct {
+	kind E
+	fn   func()
+}
+
+func (l BaseListener[E]) Kind() E {
+	return l.kind
+}
+
+func (l BaseListener[E]) Run() {
+	l.fn()
+}

pkg/expr/expr.go

@@ -0,0 +1,11 @@
+// Package expr provides the abstract Expression interface for all evaluatable
+// expression types in the lambda interpreter.
+package expr
+
+// 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.
+	String() string
+}

pkg/lambda/expression.go

@@ -1,6 +1,11 @@
 package lambda
 
+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)
 }
 
@@ -23,6 +28,10 @@ func (a *Abstraction) Accept(v Visitor) {
 	v.VisitAbstraction(a)
 }
 
+func (a *Abstraction) String() string {
+	return Stringify(a)
+}
+
 func NewAbstraction(parameter string, body Expression) *Abstraction {
 	return &Abstraction{parameter: parameter, body: body}
 }
@@ -46,6 +55,10 @@ func (a *Application) Accept(v Visitor) {
 	v.VisitApplication(a)
 }
 
+func (a *Application) String() string {
+	return Stringify(a)
+}
+
 func NewApplication(abstraction Expression, argument Expression) *Application {
 	return &Application{abstraction: abstraction, argument: argument}
 }
@@ -64,6 +77,10 @@ func (v *Variable) Accept(visitor Visitor) {
 	visitor.VisitVariable(v)
 }
 
+func (v *Variable) String() string {
+	return Stringify(v)
+}
+
 func NewVariable(name string) *Variable {
 	return &Variable{value: name}
 }

pkg/lambda/iterator.go

@@ -5,13 +5,15 @@ type Iterator struct {
 }
 
 func NewIterator(expr *Expression) *Iterator {
-	return &Iterator{
-		trace: []*Expression{expr},
+	return &Iterator{[]*Expression{expr}}
 }
+
+func (i *Iterator) Done() bool {
+	return len(i.trace) == 0
 }
 
 func (i *Iterator) Current() *Expression {
-	if len(i.trace) < 1 {
+	if i.Done() {
 		return nil
 	}
 
@@ -26,6 +28,22 @@ func (i *Iterator) Parent() *Expression {
 	return i.trace[len(i.trace)-2]
 }
 
+func (i *Iterator) Swap(with Expression) {
+	current := i.Current()
+	if current != nil {
+		*current = with
+	}
+}
+
+func (i *Iterator) Back() bool {
+	if i.Done() {
+		return false
+	}
+
+	i.trace = i.trace[:len(i.trace)-1]
+	return true
+}
+
 func (i *Iterator) Next() {
 	switch typed := (*i.Current()).(type) {
 	case *Abstraction:
@@ -48,12 +66,3 @@ func (i *Iterator) Next() {
 		i.trace = []*Expression{}
 	}
 }
-
-func (i *Iterator) Back() bool {
-	if len(i.trace) == 0 {
-		return false
-	}
-
-	i.trace = i.trace[:len(i.trace)-1]
-	return true
-}

pkg/lambda/reduce.go

@@ -1,60 +0,0 @@
-package lambda
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/lifo"
-)
-
-func ReduceOnce(e *Expression) bool {
-	stack := lifo.New(e)
-
-	for !stack.Empty() {
-		top := stack.MustPop()
-
-		switch typed := (*top).(type) {
-		case *Abstraction:
-			stack.Push(&typed.body)
-		case *Application:
-			if fn, fnOk := typed.abstraction.(*Abstraction); fnOk {
-				*top = Substitute(fn.body, fn.parameter, typed.argument)
-				return true
-			}
-
-			stack.Push(&typed.argument)
-			stack.Push(&typed.abstraction)
-		}
-	}
-
-	return false
-}
-
-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
-	}
-}
-
-func ReduceAll(e *Expression, step func()) {
-	it := NewIterator(e)
-
-	for it.Current() != nil {
-		current := it.Current()
-
-		if fn, arg, ok := IsViable(current); !ok {
-			it.Next()
-		} else {
-			*current = Substitute(fn.body, fn.parameter, arg)
-			step()
-
-			if _, _, ok := IsViable(it.Parent()); ok {
-				it.Back()
-			} else {
-			}
-		}
-	}
-}

pkg/lambda/reducer.go

@@ -0,0 +1,61 @@
+package lambda
+
+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 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
+}
+
+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 lambda expression.
+// The expression must be a lambda.Expression; other types are returned unchanged.
+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 {
+			it.Swap(Substitute(fn.body, fn.parameter, arg))
+			r.Emit(reducer.StepEvent)
+
+			if _, _, ok := isViable(it.Parent()); ok {
+				it.Back()
+			}
+		}
+	}
+
+	r.Emit(reducer.StopEvent)
+}

pkg/lifo/lifo.go

@@ -1,35 +0,0 @@
-package lifo
-
-import "fmt"
-
-type LIFO[T any] []T
-
-func New[T any](items ...T) *LIFO[T] {
-	l := LIFO[T](items)
-	return &l
-}
-
-func (l *LIFO[T]) Push(item T) {
-	*l = append(*l, item)
-}
-
-func (l *LIFO[T]) Empty() bool {
-	return len(*l) == 0
-}
-
-func (l *LIFO[T]) MustPop() T {
-	var item T
-
-	*l, item = (*l)[:len(*l)-1], (*l)[len(*l)-1]
-	return item
-}
-
-func (l *LIFO[T]) Pop() (T, error) {
-	var item T
-
-	if l.Empty() {
-		return item, fmt.Errorf("stack is exhausted")
-	}
-
-	return l.MustPop(), nil
-}

pkg/reducer/events.go

@@ -0,0 +1,13 @@
+package reducer
+
+// Event represents lifecycle events during reduction.
+type Event int
+
+const (
+	// StartEvent is emitted before reduction begins.
+	StartEvent Event = iota
+	// StepEvent is emitted after each reduction step.
+	StepEvent
+	// StopEvent is emitted after reduction completes.
+	StopEvent
+)

pkg/reducer/reducer.go

@@ -0,0 +1,27 @@
+// Package reducer provides the abstract Reducer interface for all expression
+// reduction strategies.
+package reducer
+
+import (
+	"git.maximhutz.com/max/lambda/pkg/emitter"
+	"git.maximhutz.com/max/lambda/pkg/expr"
+)
+
+// Reducer defines the interface for expression reduction strategies.
+// Different evaluation modes (normal order, applicative order, SKI combinators,
+// etc.) implement this interface with their own reduction logic.
+//
+// Reducers also implement the Emitter interface to allow plugins to observe
+// reduction lifecycle events (Start, Step, Stop).
+type Reducer interface {
+	emitter.Emitter[Event]
+
+	// Reduce performs all reduction steps on the expression.
+	// Emits StartEvent before reduction, StepEvent after each step, and
+	// StopEvent after completion.
+	// Returns the final reduced expression.
+	Reduce()
+
+	// Expression returns the current expression state.
+	Expression() expr.Expression
+}

pkg/saccharine/token/parse.go

@@ -77,6 +77,21 @@ func getToken(i *iterator.Iterator[rune]) (*Token, error) {
 		}
 	case letter == ';':
 		return NewHardBreak(index), nil
+	case letter == '#':
+		// Skip everything until the next newline or EOF.
+		for !i.Done() {
+			r, err := i.Next()
+			if err != nil {
+				return nil, trace.Wrap(err, "error while parsing comment")
+			}
+
+			if r == '\n' {
+				// Put the newline back so it can be processed as a soft break.
+				i.Back()
+				break
+			}
+		}
+		return nil, nil
 	case unicode.IsSpace(letter):
 		return nil, nil
 	case isVariable(letter):

pkg/set/set.go

@@ -1,5 +1,7 @@
 package set
 
+import "iter"
+
 type Set[T comparable] map[T]bool
 
 func (s *Set[T]) Add(items ...T) {
@@ -34,6 +36,16 @@ func (s Set[T]) ToList() []T {
 	return list
 }
 
+func (s Set[T]) Items() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for item := range s {
+			if !yield(item) {
+				return
+			}
+		}
+	}
+}
+
 func New[T comparable](items ...T) *Set[T] {
 	result := &Set[T]{}
 

tests/church_5^5.test

@@ -0,0 +1,8 @@
+0 := \f.\x.x
+inc n := \f x.(f (n f x))
+exp n m := (m n)
+print n := (n F X)
+
+N := (inc (inc (inc (inc (inc 0)))))
+
+(print (exp N N))

tests/church_6^6.test

@@ -0,0 +1,8 @@
+0 := \f.\x.x
+inc n := \f x.(f (n f x))
+exp n m := (m n)
+print n := (n F X)
+
+N := (inc (inc (inc (inc (inc (inc 0))))))
+
+(print (exp N N))

tests/comments.expected

@@ -0,0 +1 @@
+VALUE

tests/comments.test

@@ -0,0 +1,17 @@
+# This is a full-line comment at the start
+# The following defines the identity function
+identity := \x.x # This is an end-of-line comment
+
+# Define a simple function that applies a function twice
+twice := \f.\x.(f
+    # Comments can be anywhere!
+(f x))
+
+# Test that comments don't interfere with expressions
+result := (twice identity VALUE) # Should just return VALUE
+
+# Multiple comments in a row
+# can appear anywhere
+# without breaking the code
+
+result # Final comment at the end

tests/fast_list_2^30.expected

@@ -0,0 +1 @@
+(0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (1 END)))))))))))))))))))))))))))))))

tests/fast_list_2^30.test

@@ -0,0 +1,11 @@
+fix f := (\x.(f (x x)) \x.(f (x x)))
+
+inc := (fix \self.\l.(((l \x.\y.x) ((((l \x.\y.y) \x.\y.x) \c.((c \x.\y.x) \c.((c \x.\y.y) (self ((l \x.\y.y) \x.\y.y))))) \c.((c \x.\y.x) \c.((c \x.\y.x) ((l \x.\y.y) \x.\y.y))))) \c.((c \x.\y.x) \c.((c \x.\y.x) \VAR0.\x.\y.y))))
+one := \c.((c \x.\y.x) \c.((c \x.\y.x) \VAR0.\x.\y.y))
+double := \N.\c.((c \x.\y.x) \c.((c \x.\y.y) N))
+print := (fix \self.\l.(((l \x.\y.x) (((((l \x.\y.y) \x.\y.x) 1) 0) (self ((l \x.\y.y) \x.\y.y)))) END))
+
+
+N := \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.y) \c.((c \x.\y.x) \c.((c \x.\y.x) \VAR0.\x.\y.y))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+(print N)

tests/list_2^30.expected

@@ -0,0 +1 @@
+(0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (1 END)))))))))))))))))))))))))))))))

tests/list_2^30.test

@@ -0,0 +1,52 @@
+T x y := x
+F x y := y
+if b t e := (b t e)
+
+pair a b := \c.(c a b)
+left p := (p T)
+right p := (p F)
+
+print n := (n 0 1 end)
+
+fix f := (\x.(f (x x)) \x.(f (x x)))
+
+some x := (pair T x)
+none := \.F
+isfull := left
+unwrap := right
+
+nil := none
+push i l := (some (pair i l))
+peek l := (left (unwrap l))
+pop l := (right (unwrap l))
+ 
+inc := (fix \self l.{
+  (if (isfull l)
+    (if (peek l)
+      (push F (self (pop l)))
+      (push T (pop l))
+    )
+    (push T nil)
+  )
+})
+
+print := (fix \self l.{
+  (if (isfull l)
+    ((if (peek l) 1 0) (self (pop l)))
+    END
+  )
+})
+
+one := (push T nil)
+double N := (push F N)
+
+N :=
+  (double (double (double (double (double
+  (double (double (double (double (double
+  (double (double (double (double (double
+  (double (double (double (double (double
+  (double (double (double (double (double
+  (double (double (double (double (double
+  one))))))))))))))))))))))))))))))
+
+(print N)

tests/thunk.expected

@@ -0,0 +1 @@
+VALUE

tests/thunk.test

@@ -0,0 +1 @@
+(\.VALUE anything)