M.V. Hutz
e0114c736d
## Description The codebase currently couples the engine and plugins directly to `lambda.Expression`. This PR introduces an abstract `expr.Expression` interface to enable future support for multiple evaluation modes. - Add `pkg/expr/expr.go` with an `Expression` interface requiring a `String()` method. - Update `lambda.Expression` to embed `expr.Expression`. - Add `String()` method to `Abstraction`, `Application`, and `Variable` types. - Update plugins to use `String()` instead of `lambda.Stringify()`. ### Decisions - The `expr.Expression` interface is minimal (only `String()`) to avoid over-constraining future expression types. - The engine still stores `*lambda.Expression` directly rather than `expr.Expression`, because Go's interface semantics require pointer indirection for in-place mutation during reduction. - Future evaluation modes will implement their own concrete types satisfying `expr.Expression`. ## Benefits - Establishes a foundation for supporting multiple evaluation modes (SKI combinators, typed lambda calculus, etc.). - Plugins now use the abstract `String()` method, making them more decoupled from the lambda-specific implementation. - Prepares the codebase for a Reducer interface abstraction in a future PR. ## Checklist - [x] Code follows conventional commit format. - [x] Branch follows naming convention (`<type>/<description>`). - [x] Tests pass (if applicable). - [ ] Documentation updated (if applicable). Reviewed-on: #30 Co-authored-by: M.V. Hutz <git@maximhutz.me> Co-committed-by: M.V. Hutz <git@maximhutz.me>
37 lines
856 B
Go
37 lines
856 B
Go
// Package "engine" provides an extensible interface for users to interact with
|
|
// λ-calculus and other expression evaluation modes.
|
|
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.BaseEmitter[Event]
|
|
}
|
|
|
|
// Create a new engine, given an unreduced λ-expression.
|
|
func New(config *config.Config, expression *lambda.Expression) *Engine {
|
|
return &Engine{
|
|
Config: config,
|
|
Expression: expression,
|
|
BaseEmitter: *emitter.New[Event](),
|
|
}
|
|
}
|
|
|
|
// Begin the reduction process.
|
|
func (e *Engine) Run() {
|
|
e.Emit(StartEvent)
|
|
|
|
lambda.ReduceAll(e.Expression, func() {
|
|
e.Emit(StepEvent)
|
|
})
|
|
|
|
e.Emit(StopEvent)
|
|
}
|