fix: use loop variable instead of global ticker in GenerateFreshName (#40)

## Description

`GenerateFreshName` used a global `ticker` variable but never incremented it inside the loop.
This caused an infinite loop if the first generated name (`_0`) was already in the used set.

- Remove global `ticker` variable.
- Use loop variable `i` directly to generate candidate names.

## Benefits

- Fixes infinite loop bug when generated name collides with used set.
- Removes unnecessary global state.
- Simpler and more predictable behavior.

## Checklist

- [x] Code follows conventional commit format.
- [x] Branch follows naming convention (`<type>/<description>`). Always use underscores.
- [x] Tests pass (if applicable).
- [x] Documentation updated (if applicable).

Reviewed-on: #40
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>

.gitea/ISSUE_TEMPLATE/bug.md

@@ -1,6 +1,6 @@
 ---
 name: "Bug Report"
-about: "Report a bug or unexpected behavior in the lambda interpreter."
+about: "Report a bug or unexpected behavior in the lambda runtime."
 title: "fix: "
 ref: "main"
 assignees: []

.gitea/ISSUE_TEMPLATE/feature.md

@@ -1,6 +1,6 @@
 ---
 name: "Feature Request"
-about: "Suggest a new feature or enhancement for the lambda interpreter."
+about: "Suggest a new feature or enhancement for the lambda runtime."
 title: "feat: "
 ref: "main"
 assignees: []

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 interpreter 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 runtime 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 interpreter (use TEST=<name> to specify sample)"
+	echo "  run      - Build and run the lambda runtime (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 interpreter in Go.
+Making a lambda calculus runtime in Go.
 
 ## Things to talk about
 

cmd/lambda/lambda.go

@@ -7,7 +7,7 @@ import (
 	"git.maximhutz.com/max/lambda/internal/config"
 	"git.maximhutz.com/max/lambda/internal/plugins"
 	"git.maximhutz.com/max/lambda/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
+	"git.maximhutz.com/max/lambda/pkg/normalorder"
 	"git.maximhutz.com/max/lambda/pkg/saccharine"
 )
 
@@ -34,34 +34,34 @@ func main() {
 	logger.Info("compiled λ expression", "tree", compiled.String())
 
 	// Create reducer with the compiled expression.
-	reducer := lambda.NewNormalOrderReducer(&compiled)
+	runtime := normalorder.NewRuntime(compiled)
 
 	// If the user selected to track CPU performance, attach a profiler.
 	if options.Profile != "" {
-		plugins.NewPerformance(options.Profile, reducer)
+		plugins.NewPerformance(options.Profile, runtime)
 	}
 
 	// If the user selected to produce a step-by-step explanation, attach an
 	// observer.
 	if options.Explanation {
-		plugins.NewExplanation(reducer)
+		plugins.NewExplanation(runtime)
 	}
 
 	// If the user opted to track statistics, attach a tracker.
 	if options.Statistics {
-		plugins.NewStatistics(reducer)
+		plugins.NewStatistics(runtime)
 	}
 
 	// If the user selected for verbose debug logs, attach a reduction tracker.
 	if options.Verbose {
-		plugins.NewLogs(logger, reducer)
+		plugins.NewLogs(logger, runtime)
 	}
 
 	// Run reduction.
-	reducer.Reduce()
+	runtime.Run()
 
 	// Return the final reduced result.
-	result := reducer.Expression().String()
+	result := runtime.Expression().String()
 	err = options.Destination.Write(result)
 	cli.HandleError(err)
 }

cmd/lambda/lambda_test.go

@@ -7,12 +7,12 @@ import (
 	"testing"
 
 	"git.maximhutz.com/max/lambda/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
+	"git.maximhutz.com/max/lambda/pkg/normalorder"
 	"git.maximhutz.com/max/lambda/pkg/saccharine"
 	"github.com/stretchr/testify/assert"
 )
 
-// Helper function to run a single sample through the lambda interpreter.
+// Helper function to run a single sample through the lambda runtime.
 func runSample(samplePath string) (string, error) {
 	// Read the sample file.
 	input, err := os.ReadFile(samplePath)
@@ -30,8 +30,8 @@ func runSample(samplePath string) (string, error) {
 	compiled := convert.SaccharineToLambda(ast)
 
 	// Create and run the reducer.
-	reducer := lambda.NewNormalOrderReducer(&compiled)
-	reducer.Reduce()
+	reducer := normalorder.NewRuntime(compiled)
+	reducer.Run()
 
 	return reducer.Expression().String() + "\n", nil
 }

internal/plugins/debug.go

@@ -3,17 +3,17 @@ package plugins
 import (
 	"log/slog"
 
-	"git.maximhutz.com/max/lambda/pkg/reducer"
+	"git.maximhutz.com/max/lambda/pkg/runtime"
 )
 
 type Logs struct {
 	logger  *slog.Logger
-	reducer reducer.Reducer
+	reducer runtime.Runtime
 }
 
-func NewLogs(logger *slog.Logger, r reducer.Reducer) *Logs {
+func NewLogs(logger *slog.Logger, r runtime.Runtime) *Logs {
 	plugin := &Logs{logger, r}
-	r.On(reducer.StepEvent, plugin.Step)
+	r.On(runtime.StepEvent, plugin.Step)
 
 	return plugin
 }

internal/plugins/explanation.go

@@ -5,19 +5,19 @@ package plugins
 import (
 	"fmt"
 
-	"git.maximhutz.com/max/lambda/pkg/reducer"
+	"git.maximhutz.com/max/lambda/pkg/runtime"
 )
 
 // Track the reductions made by a reduction process.
 type Explanation struct {
-	reducer reducer.Reducer
+	reducer runtime.Runtime
 }
 
 // Attaches a new explanation tracker to a reducer.
-func NewExplanation(r reducer.Reducer) *Explanation {
+func NewExplanation(r runtime.Runtime) *Explanation {
 	plugin := &Explanation{reducer: r}
-	r.On(reducer.StartEvent, plugin.Start)
-	r.On(reducer.StepEvent, plugin.Step)
+	r.On(runtime.StartEvent, plugin.Start)
+	r.On(runtime.StepEvent, plugin.Step)
 
 	return plugin
 }

internal/plugins/performance.go

@@ -7,7 +7,7 @@ import (
 	"path/filepath"
 	"runtime/pprof"
 
-	"git.maximhutz.com/max/lambda/pkg/reducer"
+	"git.maximhutz.com/max/lambda/pkg/runtime"
 )
 
 // Observes a reduction process, and publishes a CPU performance profile on
@@ -19,10 +19,10 @@ type Performance struct {
 }
 
 // Create a performance tracker that outputs a profile to "file".
-func NewPerformance(file string, process reducer.Reducer) *Performance {
+func NewPerformance(file string, process runtime.Runtime) *Performance {
 	plugin := &Performance{File: file}
-	process.On(reducer.StartEvent, plugin.Start)
-	process.On(reducer.StopEvent, plugin.Stop)
+	process.On(runtime.StartEvent, plugin.Start)
+	process.On(runtime.StopEvent, plugin.Stop)
 
 	return plugin
 }

internal/plugins/statistics.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"git.maximhutz.com/max/lambda/internal/statistics"
-	"git.maximhutz.com/max/lambda/pkg/reducer"
+	"git.maximhutz.com/max/lambda/pkg/runtime"
 )
 
 // An observer, to track reduction performance.
@@ -16,11 +16,11 @@ type Statistics struct {
 }
 
 // Create a new reduction performance Statistics.
-func NewStatistics(r reducer.Reducer) *Statistics {
+func NewStatistics(r runtime.Runtime) *Statistics {
 	plugin := &Statistics{}
-	r.On(reducer.StartEvent, plugin.Start)
-	r.On(reducer.StepEvent, plugin.Step)
-	r.On(reducer.StopEvent, plugin.Stop)
+	r.On(runtime.StartEvent, plugin.Start)
+	r.On(runtime.StepEvent, plugin.Step)
+	r.On(runtime.StopEvent, plugin.Stop)
 
 	return plugin
 }

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 := lambda.GetFreeVariables(result)
+		freeVars := result.GetFree()
 		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(lambda.GetFreeVariables(e))
+	freshVar := lambda.GenerateFreshName(e.GetFree())
 
 	return lambda.NewApplication(
 		lambda.NewAbstraction(freshVar, e),

pkg/emitter/emitter.go

@@ -9,7 +9,7 @@ type Emitter[E comparable] interface {
 }
 
 type BaseEmitter[E comparable] struct {
-	listeners map[E]*set.Set[Listener[E]]
+	listeners map[E]set.Set[Listener[E]]
 }
 
 func (e *BaseEmitter[E]) On(kind E, fn func()) Listener[E] {
@@ -41,6 +41,6 @@ func (e *BaseEmitter[E]) Emit(event E) {
 
 func New[E comparable]() *BaseEmitter[E] {
 	return &BaseEmitter[E]{
-		listeners: map[E]*set.Set[Listener[E]]{},
+		listeners: map[E]set.Set[Listener[E]]{},
 	}
 }

pkg/expr/expr.go

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

pkg/lambda/expression.go

@@ -1,12 +1,31 @@
 package lambda
 
-import "git.maximhutz.com/max/lambda/pkg/expr"
+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
 }
 
 /** ------------------------------------------------------------------------- */
@@ -16,24 +35,22 @@ type Abstraction struct {
 	body      Expression
 }
 
-func (a *Abstraction) Parameter() string {
+var _ Expression = Abstraction{}
+
+func (a Abstraction) Parameter() string {
 	return a.parameter
 }
 
-func (a *Abstraction) Body() Expression {
+func (a Abstraction) Body() Expression {
 	return a.body
 }
 
-func (a *Abstraction) Accept(v Visitor) {
-	v.VisitAbstraction(a)
+func (a Abstraction) String() string {
+	return "\\" + a.parameter + "." + a.body.String()
 }
 
-func (a *Abstraction) String() string {
-	return Stringify(a)
-}
-
-func NewAbstraction(parameter string, body Expression) *Abstraction {
-	return &Abstraction{parameter: parameter, body: body}
+func NewAbstraction(parameter string, body Expression) Abstraction {
+	return Abstraction{parameter, body}
 }
 
 /** ------------------------------------------------------------------------- */
@@ -43,52 +60,40 @@ type Application struct {
 	argument    Expression
 }
 
-func (a *Application) Abstraction() Expression {
+var _ Expression = Application{}
+
+func (a Application) Abstraction() Expression {
 	return a.abstraction
 }
 
-func (a *Application) Argument() Expression {
+func (a Application) Argument() Expression {
 	return a.argument
 }
 
-func (a *Application) Accept(v Visitor) {
-	v.VisitApplication(a)
+func (a Application) String() string {
+	return "(" + a.abstraction.String() + " " + a.argument.String() + ")"
 }
 
-func (a *Application) String() string {
-	return Stringify(a)
-}
-
-func NewApplication(abstraction Expression, argument Expression) *Application {
-	return &Application{abstraction: abstraction, argument: argument}
+func NewApplication(abstraction Expression, argument Expression) Application {
+	return Application{abstraction, argument}
 }
 
 /** ------------------------------------------------------------------------- */
 
 type Variable struct {
-	value string
+	name string
 }
 
-func (v *Variable) Value() string {
-	return v.value
+var _ Expression = Variable{}
+
+func (v Variable) Name() string {
+	return v.name
 }
 
-func (v *Variable) Accept(visitor Visitor) {
-	visitor.VisitVariable(v)
+func (v Variable) String() string {
+	return v.name
 }
 
-func (v *Variable) String() string {
-	return Stringify(v)
-}
-
-func NewVariable(name string) *Variable {
-	return &Variable{value: name}
-}
-
-/** ------------------------------------------------------------------------- */
-
-type Visitor interface {
-	VisitAbstraction(*Abstraction)
-	VisitApplication(*Application)
-	VisitVariable(*Variable)
+func NewVariable(name string) Variable {
+	return Variable{name}
 }

pkg/lambda/generate_name.go

@@ -6,7 +6,9 @@ import (
 	"git.maximhutz.com/max/lambda/pkg/set"
 )
 
-func GenerateFreshName(used *set.Set[string]) string {
+// GenerateFreshName generates a variable name that is not in the used set.
+// 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,19 +2,18 @@ package lambda
 
 import "git.maximhutz.com/max/lambda/pkg/set"
 
-func GetFreeVariables(e Expression) *set.Set[string] {
-	switch e := e.(type) {
-	case *Variable:
-		return set.New(e.value)
-	case *Abstraction:
-		vars := GetFreeVariables(e.body)
-		vars.Remove(e.parameter)
-		return vars
-	case *Application:
-		vars := GetFreeVariables(e.abstraction)
-		vars.Merge(GetFreeVariables(e.argument))
-		return vars
-	default:
-		return nil
-	}
+func (e Variable) GetFree() set.Set[string] {
+	return set.New(e.Name())
+}
+
+func (e Abstraction) GetFree() set.Set[string] {
+	vars := e.Body().GetFree()
+	vars.Remove(e.Parameter())
+	return vars
+}
+
+func (e Application) GetFree() set.Set[string] {
+	vars := e.Abstraction().GetFree()
+	vars.Merge(e.Argument().GetFree())
+	return vars
 }

pkg/lambda/is_free_variable.go

@@ -1,14 +1,12 @@
 package lambda
 
-func IsFreeVariable(n string, e Expression) bool {
-	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 Variable) IsFree(n string) bool {
+	return e.Name() == n
+}
+
+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

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

@@ -1,61 +0,0 @@
-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/lambda/rename.go

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

pkg/lambda/stringify.go

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

pkg/lambda/substitute.go

@@ -1,46 +1,35 @@
 package lambda
 
-func Substitute(expr Expression, target string, replacement Expression) Expression {
-	switch e := expr.(type) {
-	case *Variable:
-		if e.value == target {
+func (e Variable) Substitute(target string, replacement Expression) Expression {
+	if e.Name() == target {
 		return replacement
 	}
-		return e
 
-	case *Abstraction:
-		if e.parameter == target {
+	return e
+}
+
+func (e Abstraction) Substitute(target string, replacement Expression) Expression {
+	if e.Parameter() == target {
 		return e
 	}
 
-		body := e.body
-		param := e.parameter
-		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 = Rename(body, param, freshVar)
+		body = body.Rename(param, freshVar)
 		param = freshVar
 	}
 
-		newBody := Substitute(body, target, replacement)
-		if newBody == body && param == e.parameter {
-			return e
-		}
-
+	newBody := body.Substitute(target, replacement)
 	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
-		}
-
-		return NewApplication(newAbs, newArg)
-
-	default:
-		return expr
-	}
+}
+
+func (e Application) Substitute(target string, replacement Expression) Expression {
+	abs := e.Abstraction().Substitute(target, replacement)
+	arg := e.Argument().Substitute(target, replacement)
+
+	return NewApplication(abs, arg)
 }

pkg/normalorder/reduce_once.go

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

@@ -0,0 +1,46 @@
+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/reducer/events.go

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

@@ -1,27 +0,0 @@
-// 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/runtime/events.go

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

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

@@ -4,9 +4,9 @@ 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 +14,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]) {
-	for item := range *o {
+func (s Set[T]) Merge(o Set[T]) {
+	for item := range o {
 		s.Add(item)
 	}
 }
@@ -46,8 +46,8 @@ func (s Set[T]) Items() iter.Seq[T] {
 	}
 }
 
-func New[T comparable](items ...T) *Set[T] {
-	result := &Set[T]{}
+func New[T comparable](items ...T) Set[T] {
+	result := Set[T]{}
 
 	for _, item := range items {
 		result.Add(item)

tests/church_6^6.test

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