feat: add test target to Makefile.

Added make test directive that runs tests without benchmarks.
Updated help text to include the new test target.

.gitea/ISSUE_TEMPLATE/bug.md

@@ -1,58 +0,0 @@
----
-name: "Bug Report"
-about: "Report a bug or unexpected behavior in the lambda runtime."
-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

@@ -1,44 +0,0 @@
----
-name: "Feature Request"
-about: "Suggest a new feature or enhancement for the lambda runtime."
-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

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

CLAUDE.md

@@ -37,31 +37,6 @@ 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`.
@@ -77,29 +52,3 @@ 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"
-```

LICENSE

@@ -48,7 +48,7 @@ The "source code" for a work means the preferred form of the work for making mod
 
 A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.
 
-The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code runtime used to run it.
+The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.
 
 The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those
 subprograms and other parts of the work.

Makefile

@@ -8,7 +8,7 @@ TEST=simple
 help:
 	echo "Available targets:"
 	echo "  build    - Build the lambda executable"
-	echo "  run      - Build and run the lambda runtime (use TEST=<name> to specify sample)"
+	echo "  run      - Build and run the lambda interpreter (use TEST=<name> to specify sample)"
 	echo "  profile  - Build and run with CPU profiling enabled"
 	echo "  explain  - Build and run with explanation mode and profiling"
 	echo "  graph    - Generate and open CPU profile visualization"

README.md

@@ -1,6 +1,6 @@
 # lambda
 
-Making a lambda calculus runtime in Go.
+Making a lambda calculus interpreter in Go.
 
 ## Things to talk about
 

cmd/lambda/lambda.go

@@ -5,9 +5,12 @@ import (
 
 	"git.maximhutz.com/max/lambda/internal/cli"
 	"git.maximhutz.com/max/lambda/internal/config"
-	"git.maximhutz.com/max/lambda/internal/plugins"
+	"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/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/normalorder"
+	"git.maximhutz.com/max/lambda/pkg/lambda"
 	"git.maximhutz.com/max/lambda/pkg/saccharine"
 )
 
@@ -31,37 +34,44 @@ func main() {
 
 	// Compile expression to lambda calculus.
 	compiled := convert.SaccharineToLambda(ast)
-	logger.Info("compiled λ expression", "tree", compiled.String())
+	logger.Info("compiled λ expression", "tree", lambda.Stringify(compiled))
 
-	// Create reducer with the compiled expression.
+	// Create reduction engine.
-	runtime := normalorder.NewRuntime(compiled)
+	process := engine.New(options, &compiled)
 
-	// If the user selected to track CPU performance, attach a profiler.
+	// If the user selected to track CPU performance, attach a profiler to the
+	// process.
 	if options.Profile != "" {
-		plugins.NewPerformance(options.Profile, runtime)
+		profiler := performance.Track(options.Profile)
+		process.On("start", profiler.Start)
+		process.On("end", profiler.End)
 	}
 
 	// If the user selected to produce a step-by-step explanation, attach an
-	// observer.
+	// observer here.
 	if options.Explanation {
-		plugins.NewExplanation(runtime)
+		explanation.Track(process)
 	}
 
-	// If the user opted to track statistics, attach a tracker.
+	// If the user opted to track statistics, attach a tracker here, too.
 	if options.Statistics {
-		plugins.NewStatistics(runtime)
+		statistics := statistics.Track()
+		process.On("start", statistics.Start)
+		process.On("step", statistics.Step)
+		process.On("end", statistics.End)
 	}
 
 	// If the user selected for verbose debug logs, attach a reduction tracker.
 	if options.Verbose {
-		plugins.NewLogs(logger, runtime)
+		process.On("step", func() {
+			logger.Info("reduction", "tree", lambda.Stringify(compiled))
+		})
 	}
 
-	// Run reduction.
+	process.Run()
-	runtime.Run()
 
 	// Return the final reduced result.
-	result := runtime.Expression().String()
+	result := lambda.Stringify(compiled)
 	err = options.Destination.Write(result)
 	cli.HandleError(err)
 }

cmd/lambda/lambda_test.go

@@ -6,13 +6,15 @@ import (
 	"strings"
 	"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/normalorder"
+	"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 runtime.
+// 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)
@@ -29,11 +31,21 @@ func runSample(samplePath string) (string, error) {
 	// Compile expression to lambda calculus.
 	compiled := convert.SaccharineToLambda(ast)
 
-	// Create and run the reducer.
+	// Create minimal config for benchmarking.
-	reducer := normalorder.NewRuntime(compiled)
+	cfg := &config.Config{
-	reducer.Run()
+		Source:      config.StringSource{Data: ""},
+		Destination: config.StdoutDestination{},
+		Profile:     "",
+		Explanation: false,
+		Statistics:  false,
+		Verbose:     false,
+	}
 
-	return reducer.Expression().String() + "\n", nil
+	// Create and run the engine.
+	process := engine.New(cfg, &compiled)
+	process.Run()
+
+	return lambda.Stringify(compiled) + "\n", nil
 }
 
 // Test that all samples produce expected output.

internal/engine/engine.go

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

@@ -0,0 +1,32 @@
+// 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/performance/tracker.go

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

internal/plugins/debug.go

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

internal/plugins/explanation.go

@@ -1,31 +0,0 @@
-// 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/runtime"
-)
-
-// Track the reductions made by a reduction process.
-type Explanation struct {
-	reducer runtime.Runtime
-}
-
-// Attaches a new explanation tracker to a reducer.
-func NewExplanation(r runtime.Runtime) *Explanation {
-	plugin := &Explanation{reducer: r}
-	r.On(runtime.StartEvent, plugin.Start)
-	r.On(runtime.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/statistics.go

@@ -1,44 +0,0 @@
-package plugins
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	"git.maximhutz.com/max/lambda/internal/statistics"
-	"git.maximhutz.com/max/lambda/pkg/runtime"
-)
-
-// An observer, to track reduction performance.
-type Statistics struct {
-	start time.Time
-	steps uint64
-}
-
-// Create a new reduction performance Statistics.
-func NewStatistics(r runtime.Runtime) *Statistics {
-	plugin := &Statistics{}
-	r.On(runtime.StartEvent, plugin.Start)
-	r.On(runtime.StepEvent, plugin.Step)
-	r.On(runtime.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

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

@@ -19,7 +19,7 @@ func convertAbstraction(n *saccharine.Abstraction) lambda.Expression {
 	// If the function has no parameters, it is a thunk. Lambda calculus still
 	// requires _some_ parameter exists, so generate one.
 	if len(parameters) == 0 {
-		freeVars := result.GetFree()
+		freeVars := lambda.GetFreeVariables(result)
 		freshName := lambda.GenerateFreshName(freeVars)
 		parameters = append(parameters, freshName)
 	}
@@ -63,7 +63,7 @@ func reduceLet(s *saccharine.LetStatement, e lambda.Expression) lambda.Expressio
 }
 
 func reduceDeclare(s *saccharine.DeclareStatement, e lambda.Expression) lambda.Expression {
-	freshVar := lambda.GenerateFreshName(e.GetFree())
+	freshVar := lambda.GenerateFreshName(lambda.GetFreeVariables(e))
 
 	return lambda.NewApplication(
 		lambda.NewAbstraction(freshVar, e),

pkg/deltanet/deltanet.go

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

pkg/deltanet/node.go

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

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

pkg/emitter/listener.go

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

@@ -1,15 +0,0 @@
-// Package expr provides the abstract Expression interface for all evaluatable
-// expression types in the lambda runtime.
-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 {
-	// The expression should have a human-readable representation.
-	fmt.Stringer
-}

pkg/lambda/expression.go

@@ -1,31 +1,7 @@
 package lambda
 
-import (
-	"git.maximhutz.com/max/lambda/pkg/expr"
-	"git.maximhutz.com/max/lambda/pkg/set"
-)
-
-// 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)
-
-	// Substitute replaces all free occurrences of the target variable with the
-	// replacement expression. Alpha-renaming is performed automatically to
-	// avoid variable capture.
-	Substitute(target string, replacement Expression) Expression
-
-	// GetFree returns the set of all free variable names in the expression.
-	// This function does not mutate the input expression.
-	// The returned set is newly allocated and can be modified by the caller.
-	GetFree() set.Set[string]
-
-	// Rename replaces all occurrences of the target variable name with the new name.
-	Rename(target string, newName string) Expression
-
-	// IsFree returns true if the variable name n occurs free in the expression.
-	// This function does not mutate the input expression.
-	IsFree(n string) bool
 }
 
 /** ------------------------------------------------------------------------- */
@@ -35,22 +11,20 @@ type Abstraction struct {
 	body      Expression
 }
 
-var _ Expression = Abstraction{}
+func (a *Abstraction) Parameter() string {
-
-func (a Abstraction) Parameter() string {
 	return a.parameter
 }
 
-func (a Abstraction) Body() Expression {
+func (a *Abstraction) Body() Expression {
 	return a.body
 }
 
-func (a Abstraction) String() string {
+func (a *Abstraction) Accept(v Visitor) {
-	return "\\" + a.parameter + "." + a.body.String()
+	v.VisitAbstraction(a)
 }
 
-func NewAbstraction(parameter string, body Expression) Abstraction {
+func NewAbstraction(parameter string, body Expression) *Abstraction {
-	return Abstraction{parameter, body}
+	return &Abstraction{parameter: parameter, body: body}
 }
 
 /** ------------------------------------------------------------------------- */
@@ -60,40 +34,44 @@ type Application struct {
 	argument    Expression
 }
 
-var _ Expression = Application{}
+func (a *Application) Abstraction() Expression {
-
-func (a Application) Abstraction() Expression {
 	return a.abstraction
 }
 
-func (a Application) Argument() Expression {
+func (a *Application) Argument() Expression {
 	return a.argument
 }
 
-func (a Application) String() string {
+func (a *Application) Accept(v Visitor) {
-	return "(" + a.abstraction.String() + " " + a.argument.String() + ")"
+	v.VisitApplication(a)
 }
 
-func NewApplication(abstraction Expression, argument Expression) Application {
+func NewApplication(abstraction Expression, argument Expression) *Application {
-	return Application{abstraction, argument}
+	return &Application{abstraction: abstraction, argument: argument}
 }
 
 /** ------------------------------------------------------------------------- */
 
 type Variable struct {
-	name string
+	value string
 }
 
-var _ Expression = Variable{}
+func (v *Variable) Value() string {
-
+	return v.value
-func (v Variable) Name() string {
-	return v.name
 }
 
-func (v Variable) String() string {
+func (v *Variable) Accept(visitor Visitor) {
-	return v.name
+	visitor.VisitVariable(v)
 }
 
-func NewVariable(name string) Variable {
+func NewVariable(name string) *Variable {
-	return Variable{name}
+	return &Variable{value: name}
+}
+
+/** ------------------------------------------------------------------------- */
+
+type Visitor interface {
+	VisitAbstraction(*Abstraction)
+	VisitApplication(*Application)
+	VisitVariable(*Variable)
 }

pkg/lambda/generate_name.go

@@ -6,9 +6,7 @@ import (
 	"git.maximhutz.com/max/lambda/pkg/set"
 )
 
-// GenerateFreshName generates a variable name that is not in the used set.
+func GenerateFreshName(used *set.Set[string]) string {
-// This function does not mutate the used set.
-func GenerateFreshName(used set.Set[string]) string {
 	for i := uint64(0); ; i++ {
 		attempt := "_" + string(strconv.AppendUint(nil, i, 10))
 

pkg/lambda/get_free_variables.go

@@ -2,18 +2,19 @@ package lambda
 
 import "git.maximhutz.com/max/lambda/pkg/set"
 
-func (e Variable) GetFree() set.Set[string] {
+func GetFreeVariables(e Expression) *set.Set[string] {
-	return set.New(e.Name())
+	switch e := e.(type) {
-}
+	case *Variable:
-
+		return set.New(e.value)
-func (e Abstraction) GetFree() set.Set[string] {
+	case *Abstraction:
-	vars := e.Body().GetFree()
+		vars := GetFreeVariables(e.body)
-	vars.Remove(e.Parameter())
+		vars.Remove(e.parameter)
 		return vars
-}
+	case *Application:
-
+		vars := GetFreeVariables(e.abstraction)
-func (e Application) GetFree() set.Set[string] {
+		vars.Merge(GetFreeVariables(e.argument))
-	vars := e.Abstraction().GetFree()
-	vars.Merge(e.Argument().GetFree())
 		return vars
+	default:
+		return nil
+	}
 }

pkg/lambda/is_free_variable.go

@@ -1,12 +1,14 @@
 package lambda
 
-func (e Variable) IsFree(n string) bool {
+func IsFreeVariable(n string, e Expression) bool {
-	return e.Name() == n
+	switch e := e.(type) {
+	case *Variable:
+		return e.value == n
+	case *Abstraction:
+		return e.parameter != n && IsFreeVariable(n, e.body)
+	case *Application:
+		return IsFreeVariable(n, e.abstraction) || IsFreeVariable(n, e.argument)
+	default:
+		return false
 	}
-
-func (e Abstraction) IsFree(n string) bool {
-	return e.Parameter() != n && e.Body().IsFree(n)
-}
-func (e Application) IsFree(n string) bool {
-	return e.Abstraction().IsFree(n) || e.Argument().IsFree(n)
 }

pkg/lambda/iterator.go

@@ -0,0 +1,68 @@
+package lambda
+
+type Iterator struct {
+	trace []*Expression
+}
+
+func NewIterator(expr *Expression) *Iterator {
+	return &Iterator{[]*Expression{expr}}
+}
+
+func (i *Iterator) Done() bool {
+	return len(i.trace) == 0
+}
+
+func (i *Iterator) Current() *Expression {
+	if i.Done() {
+		return nil
+	}
+
+	return i.trace[len(i.trace)-1]
+}
+
+func (i *Iterator) Parent() *Expression {
+	if len(i.trace) < 2 {
+		return nil
+	}
+
+	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:
+		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/lambda/reduce.go

@@ -0,0 +1,30 @@
+package lambda
+
+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.Done() {
+		if fn, arg, ok := IsViable(it.Current()); !ok {
+			it.Next()
+		} else {
+			it.Swap(Substitute(fn.body, fn.parameter, arg))
+			step()
+
+			if _, _, ok := IsViable(it.Parent()); ok {
+				it.Back()
+			}
+		}
+	}
+}

pkg/lambda/rename.go

@@ -1,28 +1,38 @@
 package lambda
 
-// Rename replaces all occurrences of the target variable name with the new name.
+func Rename(expr Expression, target string, newName string) Expression {
-func (e Variable) Rename(target string, newName string) Expression {
+	switch e := expr.(type) {
-	if e.Name() == target {
+	case *Variable:
+		if e.value == target {
 			return NewVariable(newName)
 		}
-
 		return e
-}
 
-func (e Abstraction) Rename(target string, newName string) Expression {
+	case *Abstraction:
-	newParam := e.Parameter()
+		newParam := e.parameter
-	if e.Parameter() == target {
+		if e.parameter == target {
 			newParam = newName
 		}
 
-	newBody := e.Body().Rename(target, newName)
+		newBody := Rename(e.body, target, newName)
+
+		if newParam == e.parameter && newBody == e.body {
+			return e
+		}
 
 		return NewAbstraction(newParam, newBody)
-}
 
-func (e Application) Rename(target string, newName string) Expression {
+	case *Application:
-	newAbs := e.Abstraction().Rename(target, newName)
+		newAbs := Rename(e.abstraction, target, newName)
-	newArg := e.Argument().Rename(target, newName)
+		newArg := Rename(e.argument, target, newName)
+
+		if newAbs == e.abstraction && newArg == e.argument {
+			return e
+		}
 
 		return NewApplication(newAbs, newArg)
+
+	default:
+		return expr
+	}
 }

pkg/lambda/stringify.go

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

pkg/lambda/substitute.go

@@ -1,35 +1,46 @@
 package lambda
 
-func (e Variable) Substitute(target string, replacement Expression) Expression {
+func Substitute(expr Expression, target string, replacement Expression) Expression {
-	if e.Name() == target {
+	switch e := expr.(type) {
+	case *Variable:
+		if e.value == target {
 			return replacement
 		}
+		return e
 
+	case *Abstraction:
+		if e.parameter == target {
 			return e
 		}
 
-func (e Abstraction) Substitute(target string, replacement Expression) Expression {
+		body := e.body
-	if e.Parameter() == target {
+		param := e.parameter
-		return e
+		if IsFreeVariable(param, replacement) {
-	}
+			freeVars := GetFreeVariables(replacement)
-
+			freeVars.Merge(GetFreeVariables(body))
-	body := e.Body()
-	param := e.Parameter()
-	if replacement.IsFree(param) {
-		freeVars := replacement.GetFree()
-		freeVars.Merge(body.GetFree())
 			freshVar := GenerateFreshName(freeVars)
-		body = body.Rename(param, freshVar)
+			body = Rename(body, param, freshVar)
 			param = freshVar
 		}
 
-	newBody := body.Substitute(target, replacement)
+		newBody := Substitute(body, target, replacement)
+		if newBody == body && param == e.parameter {
+			return e
+		}
+
 		return NewAbstraction(param, newBody)
+
+	case *Application:
+		newAbs := Substitute(e.abstraction, target, replacement)
+		newArg := Substitute(e.argument, target, replacement)
+
+		if newAbs == e.abstraction && newArg == e.argument {
+			return e
 		}
 
-func (e Application) Substitute(target string, replacement Expression) Expression {
+		return NewApplication(newAbs, newArg)
-	abs := e.Abstraction().Substitute(target, replacement)
-	arg := e.Argument().Substitute(target, replacement)
 
-	return NewApplication(abs, arg)
+	default:
+		return expr
+	}
 }

pkg/normalorder/reduce_once.go

@@ -1,34 +0,0 @@
-package normalorder
-
-import "git.maximhutz.com/max/lambda/pkg/lambda"
-
-func ReduceOnce(e lambda.Expression) (lambda.Expression, bool) {
-	switch e := e.(type) {
-	case lambda.Abstraction:
-		body, reduced := ReduceOnce(e.Body())
-		if reduced {
-			return lambda.NewAbstraction(e.Parameter(), body), true
-		}
-		return e, false
-
-	case lambda.Application:
-		if fn, fnOk := e.Abstraction().(lambda.Abstraction); fnOk {
-			return fn.Body().Substitute(fn.Parameter(), e.Argument()), true
-		}
-
-		abs, reduced := ReduceOnce(e.Abstraction())
-		if reduced {
-			return lambda.NewApplication(abs, e.Argument()), true
-		}
-
-		arg, reduced := ReduceOnce(e.Argument())
-		if reduced {
-			return lambda.NewApplication(e.Abstraction(), arg), true
-		}
-
-		return e, false
-
-	default:
-		return e, false
-	}
-}

pkg/normalorder/runtime.go

@@ -1,46 +0,0 @@
-package normalorder
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/emitter"
-	"git.maximhutz.com/max/lambda/pkg/expr"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-	"git.maximhutz.com/max/lambda/pkg/runtime"
-)
-
-// NormalOrderReducer implements normal order (leftmost-outermost) reduction
-// for lambda calculus expressions.
-type Runtime struct {
-	emitter.BaseEmitter[runtime.Event]
-	expression lambda.Expression
-}
-
-// NewNormalOrderReducer creates a new normal order reducer.
-func NewRuntime(expression lambda.Expression) *Runtime {
-	return &Runtime{
-		BaseEmitter: *emitter.New[runtime.Event](),
-		expression:  expression,
-	}
-}
-
-// Expression returns the current expression state.
-func (r *Runtime) Expression() expr.Expression {
-	return r.expression
-}
-
-func (r *Runtime) Step() bool {
-	result, done := ReduceOnce(r.expression)
-	r.expression = result
-	return !done
-}
-
-// Reduce performs normal order reduction on a lambda expression.
-// The expression must be a lambda.Expression; other types are returned unchanged.
-func (r *Runtime) Run() {
-	r.Emit(runtime.StartEvent)
-
-	for !r.Step() {
-		r.Emit(runtime.StepEvent)
-	}
-
-	r.Emit(runtime.StopEvent)
-}

pkg/runtime/events.go

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

pkg/runtime/runtime.go

@@ -1,27 +0,0 @@
-// Package runtime provides the abstract Reducer interface for all expression
-// reduction strategies.
-package runtime
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/emitter"
-	"git.maximhutz.com/max/lambda/pkg/expr"
-)
-
-// Runtime 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.
-//
-// Runtimes also implement the Emitter interface to allow plugins to observe
-// reduction lifecycle events (Start, Step, Stop).
-type Runtime interface {
-	emitter.Emitter[Event]
-
-	// Run a single step. Returns whether the runtime is complete or not.
-	Step() bool
-
-	// Run until completion.
-	Run()
-
-	// Copy the state of the runtime.
-	Expression() expr.Expression
-}

pkg/saccharine/token/parse.go

@@ -77,21 +77,6 @@ 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,12 +1,10 @@
 package set
 
-import "iter"
-
 type Set[T comparable] map[T]bool
 
-func (s Set[T]) Add(items ...T) {
+func (s *Set[T]) Add(items ...T) {
 	for _, item := range items {
-		s[item] = true
+		(*s)[item] = true
 	}
 }
 
@@ -14,14 +12,14 @@ func (s Set[T]) Has(item T) bool {
 	return s[item]
 }
 
-func (s Set[T]) Remove(items ...T) {
+func (s *Set[T]) Remove(items ...T) {
 	for _, item := range items {
-		delete(s, item)
+		delete(*s, item)
 	}
 }
 
-func (s Set[T]) Merge(o Set[T]) {
+func (s *Set[T]) Merge(o *Set[T]) {
-	for item := range o {
+	for item := range *o {
 		s.Add(item)
 	}
 }
@@ -36,18 +34,8 @@ func (s Set[T]) ToList() []T {
 	return list
 }
 
-func (s Set[T]) Items() iter.Seq[T] {
+func New[T comparable](items ...T) *Set[T] {
-	return func(yield func(T) bool) {
+	result := &Set[T]{}
-		for item := range s {
-			if !yield(item) {
-				return
-			}
-		}
-	}
-}
-
-func New[T comparable](items ...T) Set[T] {
-	result := Set[T]{}
 
 	for _, item := range items {
 		result.Add(item)

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

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

tests/comments.test

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