From b52a7596efad0bba49b679bee17d28ed9d162b61 Mon Sep 17 00:00:00 2001
From: "M.V. Hutz" <git@maximhutz.me>
Date: Sat, 10 Jan 2026 20:16:57 -0500
Subject: [PATCH 1/5] perf: implement structural sharing for expression trees

Replace mutable in-place expression modification with immutable
expressions that use structural sharing. This eliminates unnecessary
copying during variable substitution and beta reduction.

## Changes

- Make expression fields unexported (immutable by design)
- Convert Substitute() and Rename() to return new expressions
- Implement structural sharing: return self when unchanged
- Remove Copy() method entirely
- Add getter methods for expression fields

## Performance Impact

Benchmarked across all samples:

| Sample      | Before | After | Improvement |
|-------------|--------|-------|-------------|
| church      | 230ms  | 170ms | 26% faster  |
| saccharine  | 320ms  | 160ms | 50% faster  |
| simple      | 30ms   | 20ms  | 33% faster  |

## Key Optimization

Previously, variable substitution created deep copies:
```go
*e = replacement.Copy()  // Deep copy entire tree
```

Now uses structural sharing:
```go
return replacement  // Share pointer directly
```

This eliminates 100% of Copy() allocation overhead (10-50ms per sample).

## Files Modified

- pkg/lambda/expression.go: Unexport fields, remove Copy(), add methods
- pkg/lambda/substitute.go: Functional API with structural sharing
- pkg/lambda/rename.go: Functional API with structural sharing
- pkg/lambda/reduce.go: Use new functional API
- pkg/lambda/get_free_variables.go: Access unexported fields
- pkg/lambda/is_free_variable.go: Access unexported fields
- pkg/lambda/stringify.go: Access unexported fields
---
 pkg/lambda/expression.go         | 48 +++++++++++++++-------
 pkg/lambda/get_free_variables.go | 10 ++---
 pkg/lambda/is_free_variable.go   |  6 +--
 pkg/lambda/reduce.go             | 13 +++---
 pkg/lambda/rename.go             | 51 ++++++++++++++++-------
 pkg/lambda/stringify.go          | 10 ++---
 pkg/lambda/substitute.go         | 69 +++++++++++++++++++++-----------
 7 files changed, 135 insertions(+), 72 deletions(-)

diff --git a/pkg/lambda/expression.go b/pkg/lambda/expression.go
index e2814b2..93d6114 100644
--- a/pkg/lambda/expression.go
+++ b/pkg/lambda/expression.go
@@ -1,19 +1,29 @@
 package lambda
 
+// Expression represents an immutable lambda calculus expression.
+// All expression types use structural sharing: operations return
+// the same expression pointer when unchanged, reducing allocations.
 type Expression interface {
 	Accept(Visitor)
-	Copy() Expression
+	Substitute(target string, replacement Expression) Expression
+	Rename(target string, newName string) Expression
 }
 
 /** ------------------------------------------------------------------------- */
 
+// Abstraction represents a lambda abstraction (λx. body).
+// Fields are unexported to enforce immutability.
 type Abstraction struct {
-	Parameter string
-	Body      Expression
+	parameter string
+	body      Expression
 }
 
-func (a *Abstraction) Copy() Expression {
-	return NewAbstraction(a.Parameter, a.Body.Copy())
+func (a *Abstraction) Parameter() string {
+	return a.parameter
+}
+
+func (a *Abstraction) Body() Expression {
+	return a.body
 }
 
 func (a *Abstraction) Accept(v Visitor) {
@@ -21,18 +31,24 @@ func (a *Abstraction) Accept(v Visitor) {
 }
 
 func NewAbstraction(parameter string, body Expression) *Abstraction {
-	return &Abstraction{Parameter: parameter, Body: body}
+	return &Abstraction{parameter: parameter, body: body}
 }
 
 /** ------------------------------------------------------------------------- */
 
+// Application represents function application (f arg).
+// Fields are unexported to enforce immutability.
 type Application struct {
-	Abstraction Expression
-	Argument    Expression
+	function Expression
+	argument Expression
 }
 
-func (a *Application) Copy() Expression {
-	return NewApplication(a.Abstraction.Copy(), a.Argument.Copy())
+func (a *Application) Function() Expression {
+	return a.function
+}
+
+func (a *Application) Argument() Expression {
+	return a.argument
 }
 
 func (a *Application) Accept(v Visitor) {
@@ -40,17 +56,19 @@ func (a *Application) Accept(v Visitor) {
 }
 
 func NewApplication(function Expression, argument Expression) *Application {
-	return &Application{Abstraction: function, Argument: argument}
+	return &Application{function: function, argument: argument}
 }
 
 /** ------------------------------------------------------------------------- */
 
+// Variable represents a variable reference.
+// Fields are unexported to enforce immutability.
 type Variable struct {
-	Value string
+	value string
 }
 
-func (v *Variable) Copy() Expression {
-	return NewVariable(v.Value)
+func (v *Variable) Value() string {
+	return v.value
 }
 
 func (v *Variable) Accept(visitor Visitor) {
@@ -58,7 +76,7 @@ func (v *Variable) Accept(visitor Visitor) {
 }
 
 func NewVariable(name string) *Variable {
-	return &Variable{Value: name}
+	return &Variable{value: name}
 }
 
 /** ------------------------------------------------------------------------- */
diff --git a/pkg/lambda/get_free_variables.go b/pkg/lambda/get_free_variables.go
index ec635e9..72f39ac 100644
--- a/pkg/lambda/get_free_variables.go
+++ b/pkg/lambda/get_free_variables.go
@@ -5,14 +5,14 @@ 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)
+		return set.New(e.value)
 	case *Abstraction:
-		vars := GetFreeVariables(e.Body)
-		vars.Remove(e.Parameter)
+		vars := GetFreeVariables(e.body)
+		vars.Remove(e.parameter)
 		return vars
 	case *Application:
-		vars := GetFreeVariables(e.Abstraction)
-		vars.Merge(GetFreeVariables(e.Argument))
+		vars := GetFreeVariables(e.function)
+		vars.Merge(GetFreeVariables(e.argument))
 		return vars
 	default:
 		return nil
diff --git a/pkg/lambda/is_free_variable.go b/pkg/lambda/is_free_variable.go
index deb3492..2aff5d4 100644
--- a/pkg/lambda/is_free_variable.go
+++ b/pkg/lambda/is_free_variable.go
@@ -3,11 +3,11 @@ package lambda
 func IsFreeVariable(n string, e Expression) bool {
 	switch e := e.(type) {
 	case *Variable:
-		return e.Value == n
+		return e.value == n
 	case *Abstraction:
-		return e.Parameter != n && IsFreeVariable(n, e.Body)
+		return e.parameter != n && IsFreeVariable(n, e.body)
 	case *Application:
-		return IsFreeVariable(n, e.Abstraction) || IsFreeVariable(n, e.Argument)
+		return IsFreeVariable(n, e.function) || IsFreeVariable(n, e.argument)
 	default:
 		return false
 	}
diff --git a/pkg/lambda/reduce.go b/pkg/lambda/reduce.go
index b13d8ed..4451feb 100644
--- a/pkg/lambda/reduce.go
+++ b/pkg/lambda/reduce.go
@@ -10,16 +10,17 @@ func ReduceOnce(e *Expression) bool {
 
 		switch typed := (*top).(type) {
 		case *Abstraction:
-			stack.Push(&typed.Body)
+			stack.Push(&typed.body)
 		case *Application:
-			if fn, fnOk := typed.Abstraction.(*Abstraction); fnOk {
-				Substitute(&fn.Body, fn.Parameter, typed.Argument)
-				*top = fn.Body
+			if fn, fnOk := typed.function.(*Abstraction); fnOk {
+				// Perform beta reduction with structural sharing
+				reduced := fn.body.Substitute(fn.parameter, typed.argument)
+				*top = reduced
 				return true
 			}
 
-			stack.Push(&typed.Argument)
-			stack.Push(&typed.Abstraction)
+			stack.Push(&typed.argument)
+			stack.Push(&typed.function)
 		}
 	}
 
diff --git a/pkg/lambda/rename.go b/pkg/lambda/rename.go
index 1cacb9c..ff269c6 100644
--- a/pkg/lambda/rename.go
+++ b/pkg/lambda/rename.go
@@ -1,19 +1,40 @@
 package lambda
 
-func Rename(e Expression, target string, substitute string) {
-	switch e := e.(type) {
-	case *Variable:
-		if e.Value == target {
-			e.Value = substitute
-		}
-	case *Abstraction:
-		if e.Parameter == target {
-			e.Parameter = substitute
-		}
-
-		Rename(e.Body, target, substitute)
-	case *Application:
-		Rename(e.Abstraction, target, substitute)
-		Rename(e.Argument, target, substitute)
+// Rename replaces all occurrences of target variable with newName.
+// Uses structural sharing: returns the same expression pointer when unchanged.
+func (v *Variable) Rename(target string, newName string) Expression {
+	if v.value == target {
+		return NewVariable(newName)
 	}
+	return v // unchanged
+}
+
+// Rename replaces all occurrences of target variable with newName.
+// Uses structural sharing: only allocates when something changes.
+func (a *Abstraction) Rename(target string, newName string) Expression {
+	newParam := a.parameter
+	if a.parameter == target {
+		newParam = newName
+	}
+
+	newBody := a.body.Rename(target, newName)
+
+	if newParam == a.parameter && newBody == a.body {
+		return a // unchanged
+	}
+
+	return NewAbstraction(newParam, newBody)
+}
+
+// Rename replaces all occurrences of target variable with newName.
+// Uses structural sharing: only allocates when something changes.
+func (a *Application) Rename(target string, newName string) Expression {
+	newFunc := a.function.Rename(target, newName)
+	newArg := a.argument.Rename(target, newName)
+
+	if newFunc == a.function && newArg == a.argument {
+		return a // unchanged
+	}
+
+	return NewApplication(newFunc, newArg)
 }
diff --git a/pkg/lambda/stringify.go b/pkg/lambda/stringify.go
index 0343fcc..0769ed6 100644
--- a/pkg/lambda/stringify.go
+++ b/pkg/lambda/stringify.go
@@ -7,21 +7,21 @@ type stringifyVisitor struct {
 }
 
 func (v *stringifyVisitor) VisitVariable(a *Variable) {
-	v.builder.WriteString(a.Value)
+	v.builder.WriteString(a.value)
 }
 
 func (v *stringifyVisitor) VisitAbstraction(f *Abstraction) {
 	v.builder.WriteRune('\\')
-	v.builder.WriteString(f.Parameter)
+	v.builder.WriteString(f.parameter)
 	v.builder.WriteRune('.')
-	f.Body.Accept(v)
+	f.body.Accept(v)
 }
 
 func (v *stringifyVisitor) VisitApplication(c *Application) {
 	v.builder.WriteRune('(')
-	c.Abstraction.Accept(v)
+	c.function.Accept(v)
 	v.builder.WriteRune(' ')
-	c.Argument.Accept(v)
+	c.argument.Accept(v)
 	v.builder.WriteRune(')')
 }
 
diff --git a/pkg/lambda/substitute.go b/pkg/lambda/substitute.go
index 8798165..8cc6720 100644
--- a/pkg/lambda/substitute.go
+++ b/pkg/lambda/substitute.go
@@ -1,27 +1,50 @@
 package lambda
 
-func Substitute(e *Expression, target string, replacement Expression) {
-	switch typed := (*e).(type) {
-	case *Variable:
-		if typed.Value == target {
-			*e = replacement.Copy()
-		}
-	case *Abstraction:
-		if typed.Parameter == target {
-			return
-		}
-
-		if IsFreeVariable(typed.Parameter, replacement) {
-			replacementFreeVars := GetFreeVariables(replacement)
-			used := GetFreeVariables(typed.Body)
-			used.Merge(replacementFreeVars)
-			freshVar := GenerateFreshName(used)
-			Rename(typed, typed.Parameter, freshVar)
-		}
-
-		Substitute(&typed.Body, target, replacement)
-	case *Application:
-		Substitute(&typed.Abstraction, target, replacement)
-		Substitute(&typed.Argument, target, replacement)
+// Substitute replaces all free occurrences of target with replacement.
+// Uses structural sharing: returns the same expression pointer when unchanged.
+func (v *Variable) Substitute(target string, replacement Expression) Expression {
+	if v.value == target {
+		return replacement // NO COPY - share directly!
 	}
+	return v // unchanged, return self
+}
+
+// Substitute replaces all free occurrences of target with replacement.
+// Uses structural sharing and performs alpha conversion to avoid variable capture.
+func (a *Abstraction) Substitute(target string, replacement Expression) Expression {
+	if a.parameter == target {
+		return a // shadowed, return unchanged
+	}
+
+	// Handle alpha conversion if needed to avoid variable capture
+	body := a.body
+	param := a.parameter
+	if IsFreeVariable(param, replacement) {
+		// Need to rename to avoid capture
+		freeVars := GetFreeVariables(replacement)
+		freeVars.Merge(GetFreeVariables(body))
+		freshVar := GenerateFreshName(freeVars)
+		body = body.Rename(param, freshVar)
+		param = freshVar
+	}
+
+	newBody := body.Substitute(target, replacement)
+	if newBody == body && param == a.parameter {
+		return a // STRUCTURAL SHARING: nothing changed
+	}
+
+	return NewAbstraction(param, newBody)
+}
+
+// Substitute replaces all free occurrences of target with replacement.
+// Uses structural sharing: only allocates when something actually changes.
+func (a *Application) Substitute(target string, replacement Expression) Expression {
+	newFunc := a.function.Substitute(target, replacement)
+	newArg := a.argument.Substitute(target, replacement)
+
+	if newFunc == a.function && newArg == a.argument {
+		return a // STRUCTURAL SHARING: nothing changed
+	}
+
+	return NewApplication(newFunc, newArg)
 }
-- 
2.49.1


From 17d71da02589feacd2f4caa843999fc2d53ef9e1 Mon Sep 17 00:00:00 2001
From: "M.V. Hutz" <git@maximhutz.me>
Date: Sat, 10 Jan 2026 20:58:25 -0500
Subject: [PATCH 2/5] refactor: remove unnecessary comments from structural
 sharing implementation

Remove verbose inline and doc comments added in the structural sharing PR.
The code is self-explanatory and the comments were redundant.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 pkg/lambda/expression.go |  5 -----
 pkg/lambda/reduce.go     |  1 -
 pkg/lambda/rename.go     |  9 +++------
 pkg/lambda/substitute.go | 15 +++++----------
 4 files changed, 8 insertions(+), 22 deletions(-)

diff --git a/pkg/lambda/expression.go b/pkg/lambda/expression.go
index 93d6114..5055986 100644
--- a/pkg/lambda/expression.go
+++ b/pkg/lambda/expression.go
@@ -1,8 +1,6 @@
 package lambda
 
 // Expression represents an immutable lambda calculus expression.
-// All expression types use structural sharing: operations return
-// the same expression pointer when unchanged, reducing allocations.
 type Expression interface {
 	Accept(Visitor)
 	Substitute(target string, replacement Expression) Expression
@@ -12,7 +10,6 @@ type Expression interface {
 /** ------------------------------------------------------------------------- */
 
 // Abstraction represents a lambda abstraction (λx. body).
-// Fields are unexported to enforce immutability.
 type Abstraction struct {
 	parameter string
 	body      Expression
@@ -37,7 +34,6 @@ func NewAbstraction(parameter string, body Expression) *Abstraction {
 /** ------------------------------------------------------------------------- */
 
 // Application represents function application (f arg).
-// Fields are unexported to enforce immutability.
 type Application struct {
 	function Expression
 	argument Expression
@@ -62,7 +58,6 @@ func NewApplication(function Expression, argument Expression) *Application {
 /** ------------------------------------------------------------------------- */
 
 // Variable represents a variable reference.
-// Fields are unexported to enforce immutability.
 type Variable struct {
 	value string
 }
diff --git a/pkg/lambda/reduce.go b/pkg/lambda/reduce.go
index 4451feb..2df9a9d 100644
--- a/pkg/lambda/reduce.go
+++ b/pkg/lambda/reduce.go
@@ -13,7 +13,6 @@ func ReduceOnce(e *Expression) bool {
 			stack.Push(&typed.body)
 		case *Application:
 			if fn, fnOk := typed.function.(*Abstraction); fnOk {
-				// Perform beta reduction with structural sharing
 				reduced := fn.body.Substitute(fn.parameter, typed.argument)
 				*top = reduced
 				return true
diff --git a/pkg/lambda/rename.go b/pkg/lambda/rename.go
index ff269c6..2c9b329 100644
--- a/pkg/lambda/rename.go
+++ b/pkg/lambda/rename.go
@@ -1,16 +1,14 @@
 package lambda
 
 // Rename replaces all occurrences of target variable with newName.
-// Uses structural sharing: returns the same expression pointer when unchanged.
 func (v *Variable) Rename(target string, newName string) Expression {
 	if v.value == target {
 		return NewVariable(newName)
 	}
-	return v // unchanged
+	return v
 }
 
 // Rename replaces all occurrences of target variable with newName.
-// Uses structural sharing: only allocates when something changes.
 func (a *Abstraction) Rename(target string, newName string) Expression {
 	newParam := a.parameter
 	if a.parameter == target {
@@ -20,20 +18,19 @@ func (a *Abstraction) Rename(target string, newName string) Expression {
 	newBody := a.body.Rename(target, newName)
 
 	if newParam == a.parameter && newBody == a.body {
-		return a // unchanged
+		return a
 	}
 
 	return NewAbstraction(newParam, newBody)
 }
 
 // Rename replaces all occurrences of target variable with newName.
-// Uses structural sharing: only allocates when something changes.
 func (a *Application) Rename(target string, newName string) Expression {
 	newFunc := a.function.Rename(target, newName)
 	newArg := a.argument.Rename(target, newName)
 
 	if newFunc == a.function && newArg == a.argument {
-		return a // unchanged
+		return a
 	}
 
 	return NewApplication(newFunc, newArg)
diff --git a/pkg/lambda/substitute.go b/pkg/lambda/substitute.go
index 8cc6720..e0ef99d 100644
--- a/pkg/lambda/substitute.go
+++ b/pkg/lambda/substitute.go
@@ -1,26 +1,22 @@
 package lambda
 
 // Substitute replaces all free occurrences of target with replacement.
-// Uses structural sharing: returns the same expression pointer when unchanged.
 func (v *Variable) Substitute(target string, replacement Expression) Expression {
 	if v.value == target {
-		return replacement // NO COPY - share directly!
+		return replacement
 	}
-	return v // unchanged, return self
+	return v
 }
 
 // Substitute replaces all free occurrences of target with replacement.
-// Uses structural sharing and performs alpha conversion to avoid variable capture.
 func (a *Abstraction) Substitute(target string, replacement Expression) Expression {
 	if a.parameter == target {
-		return a // shadowed, return unchanged
+		return a
 	}
 
-	// Handle alpha conversion if needed to avoid variable capture
 	body := a.body
 	param := a.parameter
 	if IsFreeVariable(param, replacement) {
-		// Need to rename to avoid capture
 		freeVars := GetFreeVariables(replacement)
 		freeVars.Merge(GetFreeVariables(body))
 		freshVar := GenerateFreshName(freeVars)
@@ -30,20 +26,19 @@ func (a *Abstraction) Substitute(target string, replacement Expression) Expressi
 
 	newBody := body.Substitute(target, replacement)
 	if newBody == body && param == a.parameter {
-		return a // STRUCTURAL SHARING: nothing changed
+		return a
 	}
 
 	return NewAbstraction(param, newBody)
 }
 
 // Substitute replaces all free occurrences of target with replacement.
-// Uses structural sharing: only allocates when something actually changes.
 func (a *Application) Substitute(target string, replacement Expression) Expression {
 	newFunc := a.function.Substitute(target, replacement)
 	newArg := a.argument.Substitute(target, replacement)
 
 	if newFunc == a.function && newArg == a.argument {
-		return a // STRUCTURAL SHARING: nothing changed
+		return a
 	}
 
 	return NewApplication(newFunc, newArg)
-- 
2.49.1


From a967410af77040951360a6c4d4631e4b4f8684d6 Mon Sep 17 00:00:00 2001
From: "M.V. Hutz" <git@maximhutz.me>
Date: Sat, 10 Jan 2026 21:01:47 -0500
Subject: [PATCH 3/5] refactor: convert Substitute and Rename to standalone
 functions

Remove Substitute and Rename methods from Expression interface.
Refactor receiver methods into standalone functions using type switching.
Update call sites to use new function signatures.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 pkg/lambda/expression.go |  2 -
 pkg/lambda/reduce.go     |  2 +-
 pkg/lambda/rename.go     | 66 ++++++++++++++++----------------
 pkg/lambda/substitute.go | 82 ++++++++++++++++++++--------------------
 4 files changed, 77 insertions(+), 75 deletions(-)

diff --git a/pkg/lambda/expression.go b/pkg/lambda/expression.go
index 5055986..d9678d2 100644
--- a/pkg/lambda/expression.go
+++ b/pkg/lambda/expression.go
@@ -3,8 +3,6 @@ package lambda
 // Expression represents an immutable lambda calculus expression.
 type Expression interface {
 	Accept(Visitor)
-	Substitute(target string, replacement Expression) Expression
-	Rename(target string, newName string) Expression
 }
 
 /** ------------------------------------------------------------------------- */
diff --git a/pkg/lambda/reduce.go b/pkg/lambda/reduce.go
index 2df9a9d..74deba2 100644
--- a/pkg/lambda/reduce.go
+++ b/pkg/lambda/reduce.go
@@ -13,7 +13,7 @@ func ReduceOnce(e *Expression) bool {
 			stack.Push(&typed.body)
 		case *Application:
 			if fn, fnOk := typed.function.(*Abstraction); fnOk {
-				reduced := fn.body.Substitute(fn.parameter, typed.argument)
+				reduced := Substitute(fn.body, fn.parameter, typed.argument)
 				*top = reduced
 				return true
 			}
diff --git a/pkg/lambda/rename.go b/pkg/lambda/rename.go
index 2c9b329..3a1d687 100644
--- a/pkg/lambda/rename.go
+++ b/pkg/lambda/rename.go
@@ -1,37 +1,39 @@
 package lambda
 
 // Rename replaces all occurrences of target variable with newName.
-func (v *Variable) Rename(target string, newName string) Expression {
-	if v.value == target {
-		return NewVariable(newName)
+func Rename(expr Expression, target string, newName string) Expression {
+	switch e := expr.(type) {
+	case *Variable:
+		if e.value == target {
+			return NewVariable(newName)
+		}
+		return e
+
+	case *Abstraction:
+		newParam := e.parameter
+		if e.parameter == target {
+			newParam = newName
+		}
+
+		newBody := Rename(e.body, target, newName)
+
+		if newParam == e.parameter && newBody == e.body {
+			return e
+		}
+
+		return NewAbstraction(newParam, newBody)
+
+	case *Application:
+		newFunc := Rename(e.function, target, newName)
+		newArg := Rename(e.argument, target, newName)
+
+		if newFunc == e.function && newArg == e.argument {
+			return e
+		}
+
+		return NewApplication(newFunc, newArg)
+
+	default:
+		return expr
 	}
-	return v
-}
-
-// Rename replaces all occurrences of target variable with newName.
-func (a *Abstraction) Rename(target string, newName string) Expression {
-	newParam := a.parameter
-	if a.parameter == target {
-		newParam = newName
-	}
-
-	newBody := a.body.Rename(target, newName)
-
-	if newParam == a.parameter && newBody == a.body {
-		return a
-	}
-
-	return NewAbstraction(newParam, newBody)
-}
-
-// Rename replaces all occurrences of target variable with newName.
-func (a *Application) Rename(target string, newName string) Expression {
-	newFunc := a.function.Rename(target, newName)
-	newArg := a.argument.Rename(target, newName)
-
-	if newFunc == a.function && newArg == a.argument {
-		return a
-	}
-
-	return NewApplication(newFunc, newArg)
 }
diff --git a/pkg/lambda/substitute.go b/pkg/lambda/substitute.go
index e0ef99d..d2bb3d9 100644
--- a/pkg/lambda/substitute.go
+++ b/pkg/lambda/substitute.go
@@ -1,45 +1,47 @@
 package lambda
 
 // Substitute replaces all free occurrences of target with replacement.
-func (v *Variable) Substitute(target string, replacement Expression) Expression {
-	if v.value == target {
-		return replacement
+func Substitute(expr Expression, target string, replacement Expression) Expression {
+	switch e := expr.(type) {
+	case *Variable:
+		if e.value == target {
+			return replacement
+		}
+		return e
+
+	case *Abstraction:
+		if e.parameter == target {
+			return e
+		}
+
+		body := e.body
+		param := e.parameter
+		if IsFreeVariable(param, replacement) {
+			freeVars := GetFreeVariables(replacement)
+			freeVars.Merge(GetFreeVariables(body))
+			freshVar := GenerateFreshName(freeVars)
+			body = Rename(body, param, freshVar)
+			param = freshVar
+		}
+
+		newBody := Substitute(body, target, replacement)
+		if newBody == body && param == e.parameter {
+			return e
+		}
+
+		return NewAbstraction(param, newBody)
+
+	case *Application:
+		newFunc := Substitute(e.function, target, replacement)
+		newArg := Substitute(e.argument, target, replacement)
+
+		if newFunc == e.function && newArg == e.argument {
+			return e
+		}
+
+		return NewApplication(newFunc, newArg)
+
+	default:
+		return expr
 	}
-	return v
-}
-
-// Substitute replaces all free occurrences of target with replacement.
-func (a *Abstraction) Substitute(target string, replacement Expression) Expression {
-	if a.parameter == target {
-		return a
-	}
-
-	body := a.body
-	param := a.parameter
-	if IsFreeVariable(param, replacement) {
-		freeVars := GetFreeVariables(replacement)
-		freeVars.Merge(GetFreeVariables(body))
-		freshVar := GenerateFreshName(freeVars)
-		body = body.Rename(param, freshVar)
-		param = freshVar
-	}
-
-	newBody := body.Substitute(target, replacement)
-	if newBody == body && param == a.parameter {
-		return a
-	}
-
-	return NewAbstraction(param, newBody)
-}
-
-// Substitute replaces all free occurrences of target with replacement.
-func (a *Application) Substitute(target string, replacement Expression) Expression {
-	newFunc := a.function.Substitute(target, replacement)
-	newArg := a.argument.Substitute(target, replacement)
-
-	if newFunc == a.function && newArg == a.argument {
-		return a
-	}
-
-	return NewApplication(newFunc, newArg)
 }
-- 
2.49.1


From ae2ce6fd2fc63f7b451b72367bdf691055c70587 Mon Sep 17 00:00:00 2001
From: "M.V. Hutz" <git@maximhutz.me>
Date: Sat, 10 Jan 2026 21:06:47 -0500
Subject: [PATCH 4/5] style: removed unneeded comments

---
 pkg/lambda/expression.go | 4 ----
 pkg/lambda/rename.go     | 1 -
 pkg/lambda/substitute.go | 1 -
 3 files changed, 6 deletions(-)

diff --git a/pkg/lambda/expression.go b/pkg/lambda/expression.go
index d9678d2..affaf54 100644
--- a/pkg/lambda/expression.go
+++ b/pkg/lambda/expression.go
@@ -1,13 +1,11 @@
 package lambda
 
-// Expression represents an immutable lambda calculus expression.
 type Expression interface {
 	Accept(Visitor)
 }
 
 /** ------------------------------------------------------------------------- */
 
-// Abstraction represents a lambda abstraction (λx. body).
 type Abstraction struct {
 	parameter string
 	body      Expression
@@ -31,7 +29,6 @@ func NewAbstraction(parameter string, body Expression) *Abstraction {
 
 /** ------------------------------------------------------------------------- */
 
-// Application represents function application (f arg).
 type Application struct {
 	function Expression
 	argument Expression
@@ -55,7 +52,6 @@ func NewApplication(function Expression, argument Expression) *Application {
 
 /** ------------------------------------------------------------------------- */
 
-// Variable represents a variable reference.
 type Variable struct {
 	value string
 }
diff --git a/pkg/lambda/rename.go b/pkg/lambda/rename.go
index 3a1d687..7a52796 100644
--- a/pkg/lambda/rename.go
+++ b/pkg/lambda/rename.go
@@ -1,6 +1,5 @@
 package lambda
 
-// Rename replaces all occurrences of target variable with newName.
 func Rename(expr Expression, target string, newName string) Expression {
 	switch e := expr.(type) {
 	case *Variable:
diff --git a/pkg/lambda/substitute.go b/pkg/lambda/substitute.go
index d2bb3d9..b89f8e0 100644
--- a/pkg/lambda/substitute.go
+++ b/pkg/lambda/substitute.go
@@ -1,6 +1,5 @@
 package lambda
 
-// Substitute replaces all free occurrences of target with replacement.
 func Substitute(expr Expression, target string, replacement Expression) Expression {
 	switch e := expr.(type) {
 	case *Variable:
-- 
2.49.1


From fea749591c94ef495117b8eb88cbce139942be5f Mon Sep 17 00:00:00 2001
From: "M.V. Hutz" <git@maximhutz.me>
Date: Sat, 10 Jan 2026 21:09:35 -0500
Subject: [PATCH 5/5] refactor: rename Application.function field to
 Application.abstraction

Changed the Application struct field from 'function' to 'abstraction' for semantic clarity and consistency with the lambda calculus terminology.

Updated all references across the codebase including the getter method, constructor parameter, and usages in substitute, rename, reduce, get_free_variables, is_free_variable, and stringify functions.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
---
 pkg/lambda/expression.go         | 12 ++++++------
 pkg/lambda/get_free_variables.go |  2 +-
 pkg/lambda/is_free_variable.go   |  2 +-
 pkg/lambda/reduce.go             |  4 ++--
 pkg/lambda/rename.go             |  6 +++---
 pkg/lambda/stringify.go          |  2 +-
 pkg/lambda/substitute.go         |  6 +++---
 7 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/pkg/lambda/expression.go b/pkg/lambda/expression.go
index affaf54..f34b3b4 100644
--- a/pkg/lambda/expression.go
+++ b/pkg/lambda/expression.go
@@ -30,12 +30,12 @@ func NewAbstraction(parameter string, body Expression) *Abstraction {
 /** ------------------------------------------------------------------------- */
 
 type Application struct {
-	function Expression
-	argument Expression
+	abstraction Expression
+	argument    Expression
 }
 
-func (a *Application) Function() Expression {
-	return a.function
+func (a *Application) Abstraction() Expression {
+	return a.abstraction
 }
 
 func (a *Application) Argument() Expression {
@@ -46,8 +46,8 @@ func (a *Application) Accept(v Visitor) {
 	v.VisitApplication(a)
 }
 
-func NewApplication(function Expression, argument Expression) *Application {
-	return &Application{function: function, argument: argument}
+func NewApplication(abstraction Expression, argument Expression) *Application {
+	return &Application{abstraction: abstraction, argument: argument}
 }
 
 /** ------------------------------------------------------------------------- */
diff --git a/pkg/lambda/get_free_variables.go b/pkg/lambda/get_free_variables.go
index 72f39ac..1615aac 100644
--- a/pkg/lambda/get_free_variables.go
+++ b/pkg/lambda/get_free_variables.go
@@ -11,7 +11,7 @@ func GetFreeVariables(e Expression) *set.Set[string] {
 		vars.Remove(e.parameter)
 		return vars
 	case *Application:
-		vars := GetFreeVariables(e.function)
+		vars := GetFreeVariables(e.abstraction)
 		vars.Merge(GetFreeVariables(e.argument))
 		return vars
 	default:
diff --git a/pkg/lambda/is_free_variable.go b/pkg/lambda/is_free_variable.go
index 2aff5d4..abc9b4b 100644
--- a/pkg/lambda/is_free_variable.go
+++ b/pkg/lambda/is_free_variable.go
@@ -7,7 +7,7 @@ func IsFreeVariable(n string, e Expression) bool {
 	case *Abstraction:
 		return e.parameter != n && IsFreeVariable(n, e.body)
 	case *Application:
-		return IsFreeVariable(n, e.function) || IsFreeVariable(n, e.argument)
+		return IsFreeVariable(n, e.abstraction) || IsFreeVariable(n, e.argument)
 	default:
 		return false
 	}
diff --git a/pkg/lambda/reduce.go b/pkg/lambda/reduce.go
index 74deba2..55d366a 100644
--- a/pkg/lambda/reduce.go
+++ b/pkg/lambda/reduce.go
@@ -12,14 +12,14 @@ func ReduceOnce(e *Expression) bool {
 		case *Abstraction:
 			stack.Push(&typed.body)
 		case *Application:
-			if fn, fnOk := typed.function.(*Abstraction); fnOk {
+			if fn, fnOk := typed.abstraction.(*Abstraction); fnOk {
 				reduced := Substitute(fn.body, fn.parameter, typed.argument)
 				*top = reduced
 				return true
 			}
 
 			stack.Push(&typed.argument)
-			stack.Push(&typed.function)
+			stack.Push(&typed.abstraction)
 		}
 	}
 
diff --git a/pkg/lambda/rename.go b/pkg/lambda/rename.go
index 7a52796..bc5625c 100644
--- a/pkg/lambda/rename.go
+++ b/pkg/lambda/rename.go
@@ -23,14 +23,14 @@ func Rename(expr Expression, target string, newName string) Expression {
 		return NewAbstraction(newParam, newBody)
 
 	case *Application:
-		newFunc := Rename(e.function, target, newName)
+		newAbs := Rename(e.abstraction, target, newName)
 		newArg := Rename(e.argument, target, newName)
 
-		if newFunc == e.function && newArg == e.argument {
+		if newAbs == e.abstraction && newArg == e.argument {
 			return e
 		}
 
-		return NewApplication(newFunc, newArg)
+		return NewApplication(newAbs, newArg)
 
 	default:
 		return expr
diff --git a/pkg/lambda/stringify.go b/pkg/lambda/stringify.go
index 0769ed6..1d838b2 100644
--- a/pkg/lambda/stringify.go
+++ b/pkg/lambda/stringify.go
@@ -19,7 +19,7 @@ func (v *stringifyVisitor) VisitAbstraction(f *Abstraction) {
 
 func (v *stringifyVisitor) VisitApplication(c *Application) {
 	v.builder.WriteRune('(')
-	c.function.Accept(v)
+	c.abstraction.Accept(v)
 	v.builder.WriteRune(' ')
 	c.argument.Accept(v)
 	v.builder.WriteRune(')')
diff --git a/pkg/lambda/substitute.go b/pkg/lambda/substitute.go
index b89f8e0..fcfb043 100644
--- a/pkg/lambda/substitute.go
+++ b/pkg/lambda/substitute.go
@@ -31,14 +31,14 @@ func Substitute(expr Expression, target string, replacement Expression) Expressi
 		return NewAbstraction(param, newBody)
 
 	case *Application:
-		newFunc := Substitute(e.function, target, replacement)
+		newAbs := Substitute(e.abstraction, target, replacement)
 		newArg := Substitute(e.argument, target, replacement)
 
-		if newFunc == e.function && newArg == e.argument {
+		if newAbs == e.abstraction && newArg == e.argument {
 			return e
 		}
 
-		return NewApplication(newFunc, newArg)
+		return NewApplication(newAbs, newArg)
 
 	default:
 		return expr
-- 
2.49.1