M.V. Hutz
9c7fb8ceba
## Description The codebase previously used "interpreter" terminology and standalone functions for expression operations. This PR modernizes the architecture by renaming to "runtime" and converting operations to receiver methods. - Rename `pkg/interpreter` to `pkg/runtime`. - Move `ReduceOnce` to new `pkg/normalorder` package for reduction strategy isolation. - Convert standalone functions (`Substitute`, `Rename`, `GetFree`, `IsFree`) to receiver methods on concrete expression types. - Change `Set` from pointer receivers to value receivers for simpler usage. - Update all references from "interpreter" to "runtime" terminology throughout the codebase. ### Decisions - Operations like `Substitute`, `Rename`, `GetFree`, and `IsFree` are now methods on the `Expression` interface, implemented by each concrete type (`Variable`, `Abstraction`, `Application`). - The `normalorder` package isolates the normal-order reduction strategy, allowing future reduction strategies to be added in separate packages. - `Set` uses value receivers since Go maps are reference types and don't require pointer semantics. ## Benefits - Cleaner API: `expr.Substitute(target, replacement)` instead of `Substitute(expr, target, replacement)`. - Better separation of concerns: reduction strategies are isolated from expression types. - Consistent terminology: "runtime" better reflects the execution model. - Simpler `Set` usage without needing to manage pointers. ## 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: #39 Co-authored-by: M.V. Hutz <git@maximhutz.me> Co-committed-by: M.V. Hutz <git@maximhutz.me>
47 lines
1.1 KiB
Go
47 lines
1.1 KiB
Go
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)
|
|
}
|