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
 }
 
 /** ------------------------------------------------------------------------- */

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
 			}

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 {
+func Rename(expr Expression, target string, newName string) Expression {
-	if v.value == target {
+	switch e := expr.(type) {
+	case *Variable:
+		if e.value == target {
 			return NewVariable(newName)
 		}
-	return v
+		return e
-}
 
-// Rename replaces all occurrences of target variable with newName.
+	case *Abstraction:
-func (a *Abstraction) Rename(target string, newName string) Expression {
+		newParam := e.parameter
-	newParam := a.parameter
+		if e.parameter == target {
-	if a.parameter == target {
 			newParam = newName
 		}
 
-	newBody := a.body.Rename(target, newName)
+		newBody := Rename(e.body, target, newName)
 
-	if newParam == a.parameter && newBody == a.body {
+		if newParam == e.parameter && newBody == e.body {
-		return a
+			return e
 		}
 
 		return NewAbstraction(newParam, newBody)
-}
 
-// Rename replaces all occurrences of target variable with newName.
+	case *Application:
-func (a *Application) Rename(target string, newName string) Expression {
+		newFunc := Rename(e.function, target, newName)
-	newFunc := a.function.Rename(target, newName)
+		newArg := Rename(e.argument, target, newName)
-	newArg := a.argument.Rename(target, newName)
 
-	if newFunc == a.function && newArg == a.argument {
+		if newFunc == e.function && newArg == e.argument {
-		return a
+			return e
 		}
 
 		return NewApplication(newFunc, newArg)
+
+	default:
+		return expr
+	}
 }

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 {
+func Substitute(expr Expression, target string, replacement Expression) Expression {
-	if v.value == target {
+	switch e := expr.(type) {
+	case *Variable:
+		if e.value == target {
 			return replacement
 		}
-	return v
+		return e
-}
 
-// Substitute replaces all free occurrences of target with replacement.
+	case *Abstraction:
-func (a *Abstraction) Substitute(target string, replacement Expression) Expression {
+		if e.parameter == target {
-	if a.parameter == target {
+			return e
-		return a
 		}
 
-	body := a.body
+		body := e.body
-	param := a.parameter
+		param := e.parameter
 		if IsFreeVariable(param, replacement) {
 			freeVars := GetFreeVariables(replacement)
 			freeVars.Merge(GetFreeVariables(body))
 			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 == a.parameter {
+		if newBody == body && param == e.parameter {
-		return a
+			return e
 		}
 
 		return NewAbstraction(param, newBody)
-}
 
-// Substitute replaces all free occurrences of target with replacement.
+	case *Application:
-func (a *Application) Substitute(target string, replacement Expression) Expression {
+		newFunc := Substitute(e.function, target, replacement)
-	newFunc := a.function.Substitute(target, replacement)
+		newArg := Substitute(e.argument, target, replacement)
-	newArg := a.argument.Substitute(target, replacement)
 
-	if newFunc == a.function && newArg == a.argument {
+		if newFunc == e.function && newArg == e.argument {
-		return a
+			return e
 		}
 
 		return NewApplication(newFunc, newArg)
+
+	default:
+		return expr
+	}
 }