mvhutz/lambda
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: mvhutz:19d0e6d3ea60260f0bb55517054e2c20e98c3b4c
Branches Tags
mvhutz:main mvhutz:feat/updated-arch mvhutz:feat/upgrade mvhutz:feat/debruijn-engine
...
compare: mvhutz:feat/upgrade
Branches Tags
mvhutz:feat/updated-arch mvhutz:feat/upgrade mvhutz:main mvhutz:feat/debruijn-engine

29 Commits
19d0e6d3ea ... feat/upgra

Author SHA1 Message Date
M.V. Hutz
30e3bfe8f8 style: scanner not lexer 2026-01-19 19:40:55 -05:00
M.V. Hutz
091bc70172 feat: copied code over 2026-01-19 19:32:08 -05:00
M.V. Hutz
5f2dcc9394 feat: progress 2026-01-18 18:27:48 -05:00
M.V. Hutz
f2c8d9f7d2 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>
 2026-01-18 20:58:23 +00:00
M.V. Hutz
9c7fb8ceba refactor: rename interpreter to runtime and use receiver methods (#39) 
## 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>
 2026-01-18 20:52:34 +00:00
M.V. Hutz
e85cf7ceff refactor: make lambda expression types immutable (#38) 
## Summary

- Change Abstraction, Application, and Variable to use private fields with getter methods.
- Return value types instead of pointers from constructors.
- Update all type switches to match value types instead of pointer types.

## Test plan

- [x] All existing tests pass (`make test`).

Reviewed-on: #38
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-17 22:00:54 +00:00
M.V. Hutz
c2aa77cb92 refactor: remove visitor pattern (#37) 
## Description

The codebase previously used the visitor pattern for traversing lambda calculus expressions.
This was a hold-over from avoiding the Go-idiomatic way of handling types.
This PR removes the visitor pattern in favor of direct method implementations.

- Remove `Visitor` interface from `expression.go`.
- Remove `Accept` methods from `Abstraction`, `Application`, and `Variable`.
- Remove `Accept` from `Expression` interface.
- Delete `stringify.go` and move `String()` logic directly into each type.
- Add compile-time interface checks (`var _ Expression = (*Type)(nil)`).
- Update `expr.Expression` to embed `fmt.Stringer` instead of declaring `String() string`.

### Decisions

- Moved `String()` implementations directly into each expression type rather than using a separate recursive function, as each type's string representation is simple enough to be self-contained.

## Benefits

- Simpler, more idiomatic Go code using type methods instead of visitor pattern.
- Reduced indirection and fewer files to maintain.
- Compile-time interface satisfaction checks catch implementation errors early.

## Checklist

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

Closes #36

Reviewed-on: #37
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-17 20:46:07 +00:00
M.V. Hutz
52d40adcc6 chore: remove unused deltanet package (#35) 
## Description

The `deltanet` package was an unused stub in the codebase.
This PR removes it to reduce clutter.

- Removed `pkg/deltanet/deltanet.go`.
- Removed `pkg/deltanet/node.go`.

Closes #34

## Benefits

- Reduces codebase complexity by removing unused code.
- Eliminates potential confusion from an incomplete stub package.

## Checklist

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

Reviewed-on: #35
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-17 19:56:58 +00:00
M.V. Hutz
1974ad582f refactor: move event system to reducer, remove engine package (#32) 
## Description

This PR completes the MVC-inspired refactoring by moving the event system from the engine into the reducer.
The engine package is now removed entirely, as the reducer handles both reduction logic and lifecycle events.

- Add `pkg/reducer/events.go` with `StartEvent`, `StepEvent`, and `StopEvent`.
- Extend `Reducer` interface to embed `Emitter[Event]` and add `Expression()` method.
- Update `NormalOrderReducer` to embed `BaseEmitter` and emit lifecycle events during reduction.
- Update all plugins to attach to `Reducer` instead of `Engine`.
- Remove `internal/engine` package entirely.
- Add `Off()` method to `BaseEmitter` to complete the `Emitter` interface.
- Fix `Emitter.On` signature to use generic type `E` instead of `string`.

### Decisions

- The `Reducer` interface now combines reduction logic with event emission, making it the single orchestration point.
- Plugins attach directly to the reducer, simplifying the architecture.
- The `Expression()` method on `Reducer` provides access to current state for plugins.

## Benefits

- Simpler architecture with one fewer abstraction layer.
- Plugins are now mode-agnostic - they work with any `Reducer` implementation.
- Cleaner separation: reducers handle reduction, plugins observe via events.
- Easier to add new evaluation modes - just implement `Reducer` with embedded emitter.

## 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: #32
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-17 00:27:36 +00:00
M.V. Hutz
f8e1223463 refactor: extract Reducer interface and update engine to use abstractions (#31) 
## Description

This PR builds on #30 to complete the abstraction layer for multi-mode evaluation support.
The engine now accepts abstract `expr.Expression` and `reducer.Reducer` types instead of concrete lambda types.

- Add `pkg/reducer/reducer.go` with `Reducer` interface defining `Reduce(expr.Expression, onStep) expr.Expression`.
- Add `pkg/lambda/reducer.go` with `NormalOrderReducer` that wraps the existing `ReduceAll` logic.
- Update `engine.Engine` to store `expr.Expression` and `reducer.Reducer` instead of `*lambda.Expression`.
- Update plugins to use `expr.Expression.String()` directly (no pointer dereference needed).
- Update main and tests to instantiate `NormalOrderReducer` and pass it to the engine.

### Decisions

- The `Reducer.Reduce` method returns the final expression and calls `onStep` after each reduction step with the current state.
- `NormalOrderReducer` type-asserts to `lambda.Expression` internally; other expression types are returned unchanged.
- The engine updates its `Expression` field both during reduction (via `onStep`) and after completion.

## Benefits

- The engine is now fully decoupled from lambda-specific types.
- New evaluation modes can be added by implementing `expr.Expression` and `reducer.Reducer`.
- Plugins work with any expression type that implements `expr.Expression`.
- Prepares the codebase for SKI combinators, typed lambda calculus, or other future modes.

## Checklist

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

Closes #30

Reviewed-on: #31
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-16 23:42:07 +00:00
M.V. Hutz
e0114c736d refactor: extract abstract Expression interface (#30) 
## 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>
 2026-01-16 23:37:31 +00:00
M.V. Hutz
5c54f4e195 fix: correct event handler registration in plugins (#29) 
## Description

This PR fixes incorrect event handler registration in two plugins that were introduced in the refactoring.
The bugs prevented the plugins from functioning as intended.

Fixed issues:
- Statistics plugin was registering `plugin.Step` for `StopEvent` instead of `plugin.Stop`, preventing statistics from being printed at the end of execution.
- Logs plugin was listening to `StopEvent` instead of `StepEvent`, causing it to log only once at the end instead of on each reduction step.

## Benefits

Statistics are now correctly printed at the end of execution.
Debug logs now correctly show each reduction step instead of just the final state.
Plugins now work as originally intended before the refactoring.

## Checklist

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

Reviewed-on: #29
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-14 00:35:02 +00:00
M.V. Hutz
307b7ffd1e refactor: replace string-based emitter with type-safe generic event system (#28) 
## Description

This PR refactors the event emitter system from a string-based message passing approach to a type-safe generic implementation using typed events.
The previous system relied on string message names which were error-prone and lacked compile-time safety.
This refactoring introduces a generic `BaseEmitter[E comparable]` that provides type safety while consolidating the various tracker packages into a unified plugins architecture.

Key changes:
- Replace `Emitter` with generic `BaseEmitter[E comparable]` for type-safe event handling.
- Add `Event` type enumeration with `StartEvent`, `StepEvent`, and `StopEvent` constants.
- Create `Listener[E]` interface with `BaseListener` implementation for better abstraction.
- Consolidate `explanation`, `performance`, and `statistics` packages into unified `internal/plugins` package.
- Simplify CLI initialization by using plugin constructors that handle their own event subscriptions.
- Add `Items()` iterator method to `Set` for idiomatic Go 1.23+ range loops over sets.

### Decisions

Use generics for type-safe event handling.
This provides compile-time guarantees that event types match their handlers while maintaining flexibility for future event types.

Consolidate trackers into plugins architecture.
Previously separate packages (`explanation`, `performance`, `statistics`) now live under `internal/plugins`, making the plugin pattern explicit and easier to extend.

Plugin constructors self-register with engine.
Each plugin's `New*` constructor now handles its own event subscriptions, reducing boilerplate in the main CLI.

## Benefits

Type safety prevents runtime errors from typos in event names.
The compiler now catches mismatched event types at compile time rather than failing silently at runtime.

Cleaner plugin architecture makes adding new features easier.
New plugins follow a consistent pattern and live in a single location.

Reduced boilerplate in main CLI.
Plugin initialization is now a single function call rather than manual event registration.

Better testability through interface-based design.
The `Listener[E]` interface allows for easier mocking and testing of event handlers.

## Checklist

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

Reviewed-on: #28
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-14 00:30:21 +00:00
M.V. Hutz
335ce95c50 feat: add comment support to saccharine language (#25) 
## Description

The saccharine language previously lacked comment support, preventing proper code documentation.
This PR implements '#' comment syntax similar to Python.
Comments can appear on their own line or at the end of a line, with all content after '#' ignored until the next newline or EOF.
The tokenizer now detects '#' and skips characters appropriately without creating tokens.

### Decisions

Comments are silently consumed during tokenization rather than being preserved as tokens, keeping the token stream clean for the parser.
The implementation preserves newlines after comments by using the iterator's Back() method, allowing them to be processed as soft breaks.

## Benefits

Developers can now document their saccharine code with inline and full-line comments.
The implementation is minimal and efficient, adding no overhead to the token stream.
Tests verify that comments work correctly in various positions without breaking code execution.

## 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).

Closes #24

Reviewed-on: #25
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-13 02:00:00 +00:00
M.V. Hutz
19652563a4 docs: add issue linking instructions to PR workflow (#23) 
## Description

This PR updates CLAUDE.md to include documentation about linking issues in pull requests.
The documentation explains how to use the "Closes #<number>" syntax in commit messages and PR descriptions to automatically link and close issues when PRs are merged.

### Changes

- Added "Linking issues" section to Pull Request Management in [CLAUDE.md](CLAUDE.md:81-82).
- Documented the use of `Closes #<number>` syntax for automatic issue closure.

## Benefits

Developers will know to properly link issues in their PRs.
Issues will be automatically closed when their corresponding PRs are merged.
The repository will maintain better traceability between issues and PRs.

## 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: #23
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-13 01:45:53 +00:00
M.V. Hutz
dec9af0244 feat: add issue templates for Gitea (#22) 
## Description

This PR implements issue templates for the lambda repository to improve issue tracking and developer experience.
The templates follow Gitea best practices and provide clear guidance for users when creating issues.
Three distinct templates were created to handle different types of issues: feature requests, bug reports, and general issues.

### Changes

- Created [.gitea/ISSUE_TEMPLATE/feature.md](.gitea/ISSUE_TEMPLATE/feature.md) for feature requests and enhancements.
- Created [.gitea/ISSUE_TEMPLATE/bug.md](.gitea/ISSUE_TEMPLATE/bug.md) for bug reports.
- Created [.gitea/ISSUE_TEMPLATE/general.md](.gitea/ISSUE_TEMPLATE/general.md) for general issues.
- Updated [CLAUDE.md](CLAUDE.md) with issue management and workflow documentation.

### Decisions

All templates use Markdown format with YAML frontmatter, following the existing PR template style.
Each template includes pre-populated metadata (title prefix, labels, target branch).
Templates provide inline HTML comments to guide users without cluttering the final issue.
The templates are consistent with conventional commit format (feat:, fix:, etc.).

## Benefits

Users will have clear guidance when creating issues, reducing back-and-forth communication.
Issues will be more structured and contain necessary information for developers.
Pre-populated labels and titles ensure consistent issue categorization.
The templates align with the existing PR template style for a cohesive experience.

## 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: #22
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-13 01:43:36 +00:00
M.V. Hutz
dbc3c5a8d4 Improve testing infrastructure with dynamic discovery and validation (#20) 
## Summary

This PR enhances the testing infrastructure with dynamic test discovery, automated validation, and improved error handling.

## Changes

### Testing Infrastructure
- Added `TestSamplesValidity` integration test that validates all test files against their expected output.
- Implemented dynamic test discovery using `filepath.Glob` to automatically find all `.test` files.
- Renamed `benchmark_test.go` to `lambda_test.go` for better naming consistency.
- Consolidated helper functions into a single `runSample` function.
- Replaced all error handling with `assert` for consistent and clear test output.
- Required all `.test` files to have corresponding `.expected` files.

### Iterator Improvements
- Added `Swap` method to iterator for better reduction algorithm.
- Improved reduction algorithm with LIFO-based iterator implementation.

### Build System
- Added `make test` target to run tests without benchmarks.
- Updated Makefile help text to include the new test target.

### Test Cases
- Added new test cases with expected outputs: `church_5^5`, `church_6^6`, `fast_list_2^30`, `list_2^30`.
- Added validation files for all test cases.

## Test plan

- Run tests with expected output validation.
- Run benchmarks to ensure performance is maintained.
- Verify make targets work correctly.

Reviewed-on: #20
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-13 01:20:47 +00:00
M.V. Hutz
15c904ccc9 feat: improve reduction algorithm with LIFO-based iterator (#15) 
## Description

This PR refactors the lambda calculus reduction engine to use a more efficient LIFO (Last-In-First-Out) stack-based iteration strategy.
Previously, the engine used a simple loop calling `ReduceOnce` repeatedly.
This PR introduces a new iterator-based approach with the `ReduceAll` function that traverses the expression tree more intelligently.

Changes include:

- Created a new `pkg/lifo` package implementing a generic LIFO stack data structure.
- Added `pkg/lambda/iterator.go` with an `Iterator` type for traversing lambda expressions.
- Refactored `pkg/lambda/reduce.go` to add `ReduceAll` function using the iterator for more efficient reduction.
- Updated `internal/engine/engine.go` to use `ReduceAll` instead of looping `ReduceOnce`.
- Renamed sample test files from `.txt` to `.test` extension.
- Fixed `.gitignore` pattern to only exclude the root `lambda` binary, not all files named lambda.
- Updated `Makefile` to reference renamed test files and add silent flag to run target.

### Decisions

- Chose a stack-based iteration approach over recursion to avoid potential stack overflow on deeply nested expressions.
- Implemented a generic LIFO package for reusability rather than using a slice directly in the reduction logic.
- Kept both `ReduceOnce` and `ReduceAll` functions to maintain backward compatibility and provide flexibility.

## Performance

Benchmark results comparing main branch vs this PR on Apple M3:

| Test | Before (ms/op) | After (ms/op) | Change |
|------|----------------|---------------|--------|
| Thunk | 0.014 | 0.014 | 0.00% |
| Fast | 1.29 | 1.20 | **-7.04%** |
| Simple | 21.51 | 6.45 | **-70.01%** |
| Church | 157.67 | 43.00 | -76.788% |
| Saccharine | 185.25 | 178.99 | **-3.38%** |

**Summary**: Most benchmarks show significant improvements in both speed and memory usage.
The Church benchmark shows a regression that needs investigation.

## Benefits

- More efficient expression tree traversal with the iterator pattern.
- Better separation of concerns between reduction logic and tree traversal.
- Generic LIFO stack can be reused in other parts of the codebase.
- Cleaner engine implementation with callback-based step emission.

## Checklist

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

Reviewed-on: #15
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-12 02:16:07 +00:00
M.V. Hutz
609fe05250 feat: add benchmark target to Makefile (#14) 
## Description

This PR adds benchmarking capabilities to the lambda interpreter.
The benchmarks measure performance across all sample files in the samples folder.
This enables consistent performance testing and helps track optimization improvements over time.

Changes in this PR:
- Added new `bench` target to Makefile for running Go benchmarks.
- Created `benchmark_test.go` with sub-benchmarks for each sample file (Church, Fast, Saccharine, Simple, Thunk).
- Used `b.Run` for organizing sample-specific sub-benchmarks and `b.Loop` for efficient iteration.
- Configured benchmarks to use fixed iterations (10x) and 4 CPU cores for reproducible results.

### Decisions

Used `b.Loop()` instead of traditional `for i := 0; i < b.N; i++` pattern.
This is the modern Go benchmarking idiom that provides better performance measurement.

Benchmarks run the full pipeline (parse, compile, execute, stringify) to measure end-to-end performance for each sample.

## Benefits

Provides quantitative performance metrics for the lambda interpreter.
Enables tracking performance improvements or regressions across different sample complexities.
Consistent benchmark configuration (fixed iterations, CPU cores) ensures reproducible results for comparison.

## 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: #14
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-11 22:48:26 +00:00
M.V. Hutz
0eff85f8fa feat: add output flag (#13) 
## Description

The lambda CLI previously only wrote output to stdout using shell redirection.
This PR adds support for writing results to files using the `-o` flag.
This is implemented using a new `Destination` interface that mirrors the existing `Source` pattern.

Changes:
- Added `Destination` interface with `StdoutDestination` and `FileDestination` implementations.
- Added `-o` flag to CLI argument parser for output file specification.
- Updated `Config` to use `Destination` instead of direct output handling.
- Refactored main to use `Destination.Write()` for result output.
- Updated Makefile targets (`run`, `profile`, `explain`) to use `-o` flag instead of shell redirection.

### Decisions

The `-o` flag defaults to stdout when not specified or when set to `-`.
This maintains backward compatibility while providing explicit file output capability.

## Benefits

- Cleaner command-line interface without shell redirection.
- Symmetric design with `Source` interface for input.
- More portable across different shells and environments.
- Explicit output handling improves code clarity.

## Checklist

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

Reviewed-on: #13
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-11 22:14:48 +00:00
M.V. Hutz
62699a0e37 feat: add file input flag (#12) 
## Description

The lambda CLI previously only supported inline string expressions and stdin input.
This PR adds support for reading lambda expressions from files using the `-f` flag.
This makes it easier to work with larger programs stored in files.

Changes:
- Added `FileSource` type to `internal/config/source.go` for reading from file paths.
- Added `-f` flag to CLI argument parser with validation to prevent conflicting inputs.
- Updated Makefile targets (`run`, `profile`, `explain`) to use `-f` flag instead of stdin redirection.

### Decisions

The `-f` flag takes precedence over positional arguments.
If both are specified, an error is returned to avoid ambiguity.

## Benefits

- More intuitive workflow for file-based lambda programs.
- Cleaner Makefile targets without stdin redirection.
- Consistent with common CLI conventions (e.g., `grep -f`, `awk -f`).

## Checklist

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

Reviewed-on: #12
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-11 21:43:11 +00:00
M.V. Hutz
90c205db2e refactor: improve Makefile structure and usability (#11) 
## Description

This PR refactors the Makefile to improve usability, maintainability, and cross-platform compatibility.
The changes modernize the Makefile structure and make it more user-friendly.

Changes made:
- Renamed the `it` target to `build` for better clarity and conventional naming.
- Added a `help` target as the default goal to display available targets and their descriptions.
- Moved the TEST variable to the top with other configuration variables for better organization.
- Updated binary name from `lambda.exe` to `lambda` and used `${BINARY_NAME}` variable consistently throughout.
- Replaced all `@` prefixes with the `.SILENT:` directive for cleaner syntax.
- Added a `clean` target to remove all build artifacts (binary, program.out, profile directory).
- Made the `graph` target cross-platform by replacing macOS-specific `open` command with file:// URL echo.
- Updated .gitignore to include the `lambda` binary.

### Decisions

- Used `.SILENT:` directive instead of individual `@` prefixes for a cleaner, more maintainable Makefile.
- Made `help` the default target so users can run `make` without arguments to see available commands.
- Removed platform-specific commands (like `open`) in favor of cross-platform alternatives.

## Benefits

- Improved discoverability: Users can run `make` to see all available targets.
- Better maintainability: Using `${BINARY_NAME}` variable consistently makes future changes easier.
- Cross-platform compatibility: Removed macOS-specific commands.
- Cleaner syntax: `.SILENT:` directive eliminates repetitive `@` prefixes.
- More conventional: Renamed `it` to `build` follows standard Makefile conventions.

## 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: #11
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-11 21:13:41 +00:00
M.V. Hutz
72a0afbbc0 perf: implement structural sharing for expression trees (#10) 
## Description

The profiler revealed that 75% of CPU time was spent on memory allocation, with the primary bottleneck being expression copying during variable substitution. Every time a variable was substituted with an expression, `replacement.Copy()` would create a full deep copy of the entire expression tree.

This PR refactors the lambda calculus interpreter from a mutable, pointer-based implementation to an immutable, structurally-shared implementation. Expressions are now immutable value types that share unchanged subtrees instead of copying them.

**Key changes:**
- Made expression fields unexported to enforce immutability.
- Converted `Substitute()` and `Rename()` from in-place mutation to functional methods that return new expressions.
- Implemented structural sharing: methods return the same pointer when nothing changes.
- Removed `Copy()` method entirely - no more deep copying during substitution.
- Added getter methods for accessing expression fields from outside the package.

### Decisions

**Immutability over mutation:** Switched from mutable `*Expression` pointers with in-place updates to immutable expressions that return new trees. This is a fundamental architectural shift but aligns with functional programming principles and enables structural sharing.

**Structural sharing strategy:** When `Substitute()` or `Rename()` encounters an unchanged subtree, it returns the original pointer instead of creating a new object. This is safe because expressions are now immutable.

**Field encapsulation:** Made all expression fields unexported (`Parameter` → `parameter`, `Body` → `body`, etc.) to prevent external mutation. Added getter methods for controlled access.

## Benefits

**Performance improvements** (measured across all samples):

| Sample      | Before CPU | After CPU | Improvement | Copy Overhead Eliminated |
|-------------|-----------|----------|-------------|--------------------------|
| **saccharine** | 320ms | 160ms | **50% faster** | 50ms (15.6% of total) |
| **church** | 230ms | 170ms | **26% faster** | 40ms (17.4% of total) |
| **simple** | 30ms | 20ms | **33% faster** | 10ms (33.3% of total) |

**Wall-clock improvements:**
- saccharine: 503ms → 303ms (40% faster)
- church: 404ms → 302ms (25% faster)

**Memory allocation eliminated:**
- Before: `runtime.mallocgcSmallScanNoHeader` consumed 10-50ms per sample
- After: **Completely eliminated from profile** ✨
- All `Copy()` method calls removed from hot path

**The optimization in action:**

Before:
```go
func Substitute(e *Expression, target string, replacement Expression) {
    switch typed := (*e).(type) {
    case *Variable:
        if typed.Value == target {
            *e = replacement.Copy()  // Deep copy entire tree!
        }
    }
}
```

After:
```go
func (v *Variable) Substitute(target string, replacement Expression) Expression {
    if v.value == target {
        return replacement  // Share pointer directly, no allocation
    }
    return v  // Unchanged, share self
}
```

**Codebase improvements:**
- More idiomatic functional programming style.
- Immutability prevents entire class of mutation bugs.
- Clearer ownership semantics (expressions are values, not mutable objects).
- Easier to reason about correctness (no action at a distance).

## Checklist

- [x] Code follows conventional commit format.
- [x] Branch follows naming convention (`perf/structural-sharing`).
- [x] Tests pass (no test files exist, but build succeeds and profiling confirms correctness).
- [x] Documentation updated (added comments explaining structural sharing).

Reviewed-on: #10
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-11 02:15:38 +00:00
M.V. Hutz
22019acbb1 feat: add PHONY declarations and docs target to Makefile (#9) 
---
name: "Default Template"
about: "The default template for `lambda`."
title: "feat: add PHONY declarations and docs target to Makefile"
ref: "main"
assignees: []
labels: []
---

## Description

This PR improves the Makefile by adding proper `.PHONY` declarations and a new `docs` target.
The `.PHONY` declarations ensure make properly handles targets that don't create files.
The `docs` target provides an easy way to view Go package documentation locally using godoc.

Changes:
- Add `.PHONY` declaration for all non-file targets (`it`, `run`, `profile`, `explain`, `graph`, `docs`).
- Add `docs` target that runs godoc server on port 6060 with helpful usage message.

### Decisions

None.

## Benefits

- Prevents make from getting confused if files with target names exist.
- Provides convenient documentation viewing with `make docs`.
- Improves Makefile maintainability following best practices.

## Checklist

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

Reviewed-on: #9
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-10 23:29:30 +00:00
M.V. Hutz
d831312dc3 feat: complete PR template frontmatter fields (#8) 
## Description

Adds all recommended frontmatter fields to the Gitea pull request template.
This includes `about`, `ref`, `assignees`, and `labels` fields in addition to the required `name` and `title` fields.
These fields provide better template documentation and default PR settings.

## Benefits

- The PR template now includes a description (`about`) explaining its purpose.
- Default target branch is explicitly set to `main` via the `ref` field.
- Template follows Gitea best practices with all available frontmatter fields.
- Provides a complete, well-documented template structure for contributors.

## Checklist

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

Reviewed-on: #8
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-10 23:00:32 +00:00
M.V. Hutz
c0353c8e1f feat: add required name field to PR template (#7) 
## Description

Gitea requires a `name` field in the frontmatter of pull request templates.
This PR adds the required `name: "Default Template"` field to fix the template validation error.
Additionally updates CLAUDE.md to reference the PR template format and use lowercase for PR title placeholder.

## Benefits

- The pull request template is now valid and will be properly loaded by Gitea.
- Users creating PRs will see the template automatically populated.
- CLAUDE.md now documents the PR template format for consistency.

## Checklist

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

Reviewed-on: #7
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-10 22:54:43 +00:00
M.V. Hutz
e63c0df410 fix: move PR template to correct Gitea location (#6) 
## Description

Gitea requires the pull request template to be at `.gitea/PULL_REQUEST_TEMPLATE.md` (as a file), not in a `.gitea/PULL_REQUEST_TEMPLATE/` directory.
This PR moves the template from `.gitea/PULL_REQUEST_TEMPLATE/default.md` to `.gitea/PULL_REQUEST_TEMPLATE.md` to ensure it works correctly with Gitea.

## Benefits

- The pull request template will now be automatically loaded when creating new PRs in Gitea.
- Follows Gitea's documented convention for PR templates.

## Checklist

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

Reviewed-on: #6
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-10 22:49:24 +00:00
M.V. Hutz
8b6c632e4d feat: add pull request template (#5) 
## Description

Added a standardized pull request template to improve PR quality and consistency. The template provides a clear structure for contributors to follow when creating PRs.

The template includes:
- Title placeholder following conventional commit format (`<type>: <description>`)
- Description section with guidance on context, rationale, and changes
- Optional Decisions section for architectural choices
- Benefits section to highlight improvements
- Checklist for conventional commits, branch naming, tests, and documentation

### Decisions

Created the template in `.gitea/PULL_REQUEST_TEMPLATE/default.md` to support multiple template types in the future.

## Benefits

- Ensures PRs follow project conventions (conventional commits, branch naming)
- Provides clear structure for describing changes
- Helps reviewers understand context and benefits
- Reduces back-and-forth by reminding contributors of requirements
- Supports future expansion with additional template types

Reviewed-on: #5
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-10 22:44:41 +00:00
M.V. Hutz
7a5944594f docs: add project guidelines for Claude Code (#4) 
## Summary
- Add CLAUDE.md with project guidelines
- Documents conventional commit format and types
- Specifies branch naming conventions
- Includes PR management instructions using tea CLI

## Test plan
- Review CLAUDE.md content
- Verify formatting and accuracy

Reviewed-on: #4
Co-authored-by: M.V. Hutz <git@maximhutz.me>
Co-committed-by: M.V. Hutz <git@maximhutz.me>
 2026-01-10 22:32:15 +00:00
69 changed files with 977 additions and 1014 deletions
Expand all files Collapse all files

58
.gitea/ISSUE_TEMPLATE/bug.md Normal file
View File

@@ -0,0 +1,58 @@
---
name: "Bug Report"
about: "Report a bug or unexpected behavior in the lambda runtime."
title: "fix: "
ref: "main"
assignees: []
labels:
- bug
---
## Context
<!--
Describe what you were trying to do when you encountered the bug.
Explain what you expected to happen.
-->
## Current Behavior
<!--
Describe what actually happened.
Be specific about the incorrect behavior or error.
-->
## Steps to Reproduce
<!--
Provide step-by-step instructions to reproduce the issue.
Include any relevant code, commands, or input.
-->
1.
2.
3.
## Expected Behavior
<!--
Describe what should happen instead.
-->
## Environment
<!--
Provide relevant information about your environment.
-->
- Lambda version:
- Go version:
- Operating system:
## Additional Context
<!--
Add any other context about the problem.
Include error messages, logs, or screenshots if applicable.
If none exist, omit this section.
-->

44
.gitea/ISSUE_TEMPLATE/feature.md Normal file
View File

@@ -0,0 +1,44 @@
---
name: "Feature Request"
about: "Suggest a new feature or enhancement for the lambda runtime."
title: "feat: "
ref: "main"
assignees: []
labels:
- enhancement
---
## Context
<!--
Describe the problem or limitation you're encountering.
Explain why this feature would be valuable.
-->
## Proposed Solution
<!--
Describe your proposed solution or enhancement.
Be specific about what you want to see implemented.
-->
## Alternatives Considered
<!--
List any alternative solutions or approaches you've considered.
If none exist, omit this section.
-->
## Acceptance Criteria
<!--
List clear, testable criteria that define when this feature is complete.
Use bullet points starting with •
-->
## Additional Context
<!--
Add any other context, screenshots, or examples about the feature request.
If none exist, omit this section.
-->

37
.gitea/ISSUE_TEMPLATE/general.md Normal file
View File

@@ -0,0 +1,37 @@
---
name: "General Issue"
about: "Create an issue that doesn't fit other templates."
title: ""
ref: "main"
assignees: []
labels: []
---
## Context
<!--
Describe the background and context for this issue.
Explain why this issue exists.
-->
## Description
<!--
Provide a detailed description of what needs to be done.
Be clear and specific about the requirements.
-->
## Acceptance Criteria
<!--
List clear, testable criteria that define when this issue is complete.
Use bullet points starting with •
If none exist, omit this section.
-->
## Additional Context
<!--
Add any other relevant information, links, or references.
If none exist, omit this section.
-->

37
.gitea/PULL_REQUEST_TEMPLATE.md Normal file
View File

@@ -0,0 +1,37 @@
---
name: "Default Template"
about: "The default template for `lambda`."
title: "<type>: <description>"
ref: "main"
assignees: []
labels: []
---
## Description
<!--
First, describe the context for the PR.
Then, explain why the PR exists.
Finally, in concise, sentence-long bullets, explain each change.
-->
### Decisions
<!--
List any major architectural decisions here.
If none exist, omit this section.
-->
## Benefits
<!--
List any major benefits here.
How would this PR improve the codebase/product?
-->
## Checklist
- [ ] Code follows conventional commit format.
- [ ] Branch follows naming convention (`<type>/<description>`). Always use underscores.
- [ ] Tests pass (if applicable).
- [ ] Documentation updated (if applicable).

4
.gitignore vendored
View File

@@ -3,15 +3,13 @@
# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
# #
# Binaries for programs and plugins # Binaries for programs and plugins
/lambda
*.exe *.exe
*.exe~ *.exe~
*.dll *.dll
*.so *.so
*.dylib *.dylib
# Test binary, built with `go test -c`
*.test
# Output of the go coverage tool, specifically when used with LiteIDE # Output of the go coverage tool, specifically when used with LiteIDE
*.out *.out

105
CLAUDE.md Normal file
View File

@@ -0,0 +1,105 @@
# Guide To `lambda`
## Documentation Style
Use full sentences.
Every sentence gets its own line in Markdown.
Every sentence ends in a period.
## Coding Style
### Conventional Commits
Use conventional commit format: `<type>: <description>`.
**Types**: `feat`, `fix`, `docs`, `refactor`, `test`, `chore`, `perf`
**Examples**:
- `feat: add explanation mode flag to CLI`
- `fix: correct variable renaming in nested abstractions`
- `docs: update Makefile documentation`
DO NOT advertise Claude.
### Branch Names
Use format: `<type>/<description>` with kebab-case.
**Types**: Same as commits: `feat`, `fix`, `docs`, `refactor`, `test`, `chore`, `perf`.
**Examples**:
- `feat/explanation-mode`
- `fix/variable-renaming`
- `docs/makefile-improvements`
- `refactor/silent-directive`
DO NOT advertise Claude.
## Issue Management
Use the `tea` CLI (Gitea command-line tool) for issue operations.
**Common commands**:
- `tea issues list` - List all issues.
- `tea issues <number>` - View details of a specific issue.
- `tea issues create --title "<title>" --body "<description>"` - Create a new issue.
- `tea issues close <number>` - Close an issue.
**Reading issues**: Use `tea issues <number>` to read the full details of an issue before starting work.
## Issue Workflow
When working on an issue:
1. Read the issue using `tea issues <number>` to understand requirements.
2. Create a feature branch following the branch naming convention.
3. Make commits following the conventional commit format.
4. Submit a pull request when ready.
**Important**: Never commit directly to `main`.
All work must be done in a feature branch and submitted via pull request.
## Pull Request Management
Use the `tea` CLI (Gitea command-line tool) for PR operations instead of `gh`.
**Common commands**:
- `tea pr create --title "<title>" --description "<body>"` - Create a new pull request.
- `tea pr list` - List pull requests.
- `tea pr checkout <number>` - Check out a PR locally.
- `tea pr close <number>` - Close a pull request.
- `tea pr merge <number>` - Merge a pull request.
**Note**: Use `--description` (not `--body`) for PR body content.
**Creating PRs**: Always create PRs in a branch other than `main`, to the `main` branch unless specified otherwise. ALWAYS FOLLOW THE PR TEMPLATE, EXACTLY.
**Linking issues**: When a PR solves an issue, reference the issue in both the commit message and PR description using `Closes #<number>`.
This automatically links and closes the issue when the PR is merged.
### Updating PRs
When pushing additional changes to an existing PR, add a comment summarizing the new commits.
This keeps reviewers informed of what changed since the initial PR description.
Use the `tea` CLI to add comments to pull requests:
```bash
tea comment <number> "Comment text"
```
#### Examples
```bash
# Add a comment to PR #42
tea comment 42 "Updated implementation based on feedback"
# Add a multi-line comment
tea comment 42 "Summary of changes:
- Fixed bug in reducer
- Added new tests"
```

2
LICENSE
View File

@@ -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. 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 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. subprograms and other parts of the work.

41
Makefile
View File

@@ -1,21 +1,32 @@
BINARY_NAME=lambda.exe BINARY_NAME=lambda
it: .PHONY: help build docs test bench clean
@ go build -o ${BINARY_NAME} ./cmd/lambda .DEFAULT_GOAL := help
@ chmod +x ${BINARY_NAME} .SILENT:
TEST=simple help:
echo "Available targets:"
echo " build - Build the lambda executable"
echo " docs - Start local godoc server on port 6060"
echo " test - Run tests"
echo " bench - Run benchmarks"
echo " clean - Remove all build artifacts"
run: it build:
@ ./lambda.exe - < ./samples/$(TEST).txt > program.out go build -o ${BINARY_NAME} ./cmd/lambda
chmod +x ${BINARY_NAME}
profile: it docs:
@ ./lambda.exe -p profile/cpu.prof - < ./samples/$(TEST).txt > program.out echo ">>> View at 'http://localhost:6060/pkg/git.maximhutz.com/max/lambda/'"
go run golang.org/x/tools/cmd/godoc@latest -http=:6060
explain: it test:
@ ./lambda.exe -x -p profile/cpu.prof - < ./samples/$(TEST).txt > program.out go test -v ./...
graph: bench:
@ go tool pprof -raw -output=profile/cpu.raw profile/cpu.prof go test -bench=. -benchtime=10x -cpu=4 ./...
@ go tool pprof -svg profile/cpu.prof > profile/cpu.svg
@ open profile/cpu.svg clean:
rm -f ${BINARY_NAME}
rm -f program.out
rm -rf profile/

2
README.md
View File

@@ -1,6 +1,6 @@
# lambda # lambda
Making a lambda calculus interpreter in Go. Making a lambda calculus runtime in Go.
## Things to talk about ## Things to talk about

30
cmd/lambda/convert.go Normal file
View File

@@ -0,0 +1,30 @@
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
var convertCmd = &cobra.Command{
Use: "convert [input] [output]",
Short: "Convert between lambda calculus representations",
Long: `Convert lambda calculus expressions between different representations.
The format is inferred from file extensions when possible.
Use --from and --to flags to override format detection.`,
Example: ` lambda convert input.sch output.dbi
lambda convert input.txt output.txt --from saccharine --to lambda`,
Args: cobra.ExactArgs(2),
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintln(os.Stderr, "not implemented")
os.Exit(1)
},
}
func init() {
convertCmd.Flags().String("from", "", "source format")
convertCmd.Flags().String("to", "", "target format")
rootCmd.AddCommand(convertCmd)
}

21
cmd/lambda/engine.go Normal file
View File

@@ -0,0 +1,21 @@
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
var engineCmd = &cobra.Command{
Use: "engine",
Short: "List available evaluation engines",
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintln(os.Stderr, "not implemented")
os.Exit(1)
},
}
func init() {
rootCmd.AddCommand(engineCmd)
}

76
cmd/lambda/lambda.go
View File

@@ -1,76 +0,0 @@
package main
import (
"fmt"
"os"
"git.maximhutz.com/max/lambda/internal/cli"
"git.maximhutz.com/max/lambda/internal/config"
"git.maximhutz.com/max/lambda/internal/engine"
"git.maximhutz.com/max/lambda/internal/explanation"
"git.maximhutz.com/max/lambda/internal/performance"
"git.maximhutz.com/max/lambda/internal/statistics"
"git.maximhutz.com/max/lambda/pkg/convert"
"git.maximhutz.com/max/lambda/pkg/lambda"
"git.maximhutz.com/max/lambda/pkg/saccharine"
)
func main() {
// Parse CLI arguments.
options, err := config.FromArgs()
cli.HandleError(err)
logger := options.GetLogger()
logger.Info("using program arguments", "args", os.Args)
logger.Info("parsed CLI options", "options", options)
// Get input.
input, err := options.Source.Extract()
cli.HandleError(err)
// Parse code into syntax tree.
ast, err := saccharine.Parse(input)
cli.HandleError(err)
logger.Info("parsed syntax tree", "tree", ast)
// Compile expression to lambda calculus.
compiled := convert.SaccharineToLambda(ast)
logger.Info("compiled λ expression", "tree", lambda.Stringify(compiled))
// Create reduction engine.
process := engine.New(options, &compiled)
// If the user selected to track CPU performance, attach a profiler to the
// process.
if options.Profile != "" {
profiler := performance.Track(options.Profile)
process.On("start", profiler.Start)
process.On("end", profiler.End)
}
// If the user selected to produce a step-by-step explanation, attach an
// observer here.
if options.Explanation {
explanation.Track(process)
}
// If the user opted to track statistics, attach a tracker here, too.
if options.Statistics {
statistics := statistics.Track()
process.On("start", statistics.Start)
process.On("step", statistics.Step)
process.On("end", statistics.End)
}
// If the user selected for verbose debug logs, attach a reduction tracker.
if options.Verbose {
process.On("step", func() {
logger.Info("reduction", "tree", lambda.Stringify(compiled))
})
}
process.Run()
// Return the final reduced result.
fmt.Println(lambda.Stringify(compiled))
}

27
cmd/lambda/repl.go Normal file
View File

@@ -0,0 +1,27 @@
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
var replCmd = &cobra.Command{
Use: "repl",
Short: "Start an interactive lambda calculus REPL",
Long: `Start an interactive Read-Eval-Print Loop for lambda calculus.
Enter lambda expressions to evaluate them.
Type 'exit' or 'quit' to leave the REPL.
Press Ctrl+D to exit.`,
Example: ` lambda repl`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintln(os.Stderr, "not implemented")
os.Exit(1)
},
}
func init() {
rootCmd.AddCommand(replCmd)
}

21
cmd/lambda/repr.go Normal file
View File

@@ -0,0 +1,21 @@
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
var reprCmd = &cobra.Command{
Use: "repr",
Short: "List available representations",
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintln(os.Stderr, "not implemented")
os.Exit(1)
},
}
func init() {
rootCmd.AddCommand(reprCmd)
}

19
cmd/lambda/root.go Normal file
View File

@@ -0,0 +1,19 @@
package main
import (
"os"
"github.com/spf13/cobra"
)
var rootCmd = &cobra.Command{
Use: "lambda",
Short: "A lambda calculus interpreter and toolkit",
Long: `Lambda is a CLI tool for working with lambda calculus expressions.`,
}
func main() {
if err := rootCmd.Execute(); err != nil {
os.Exit(1)
}
}

31
cmd/lambda/run.go Normal file
View File

@@ -0,0 +1,31 @@
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
var runCmd = &cobra.Command{
Use: "run [expression]",
Short: "Evaluate a lambda calculus expression",
Long: `Evaluate a lambda calculus expression and print the result.
The expression can be provided as an argument, read from a file with --file,
or piped through stdin.`,
Example: ` lambda run "\x.x"
echo "\x.x" | lambda run
lambda run --file program.sch
lambda run --file program.sch --engine krivine`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintln(os.Stderr, "not implemented")
os.Exit(1)
},
}
func init() {
runCmd.Flags().StringP("file", "f", "", "read expression from file")
runCmd.Flags().StringP("engine", "e", "normal", "evaluation engine to use")
rootCmd.AddCommand(runCmd)
}

28
cmd/lambda/trace.go Normal file
View File

@@ -0,0 +1,28 @@
package main
import (
"fmt"
"os"
"github.com/spf13/cobra"
)
var traceCmd = &cobra.Command{
Use: "trace [file]",
Short: "Trace the evaluation of a lambda calculus expression",
Long: `Trace the step-by-step evaluation of a lambda calculus expression.
This command shows each reduction step during evaluation.`,
Example: ` lambda trace program.sch
lambda trace program.sch --engine krivine`,
Args: cobra.ExactArgs(1),
Run: func(cmd *cobra.Command, args []string) {
fmt.Fprintln(os.Stderr, "not implemented")
os.Exit(1)
},
}
func init() {
traceCmd.Flags().StringP("engine", "e", "normal", "evaluation engine to use")
rootCmd.AddCommand(traceCmd)
}

11
go.mod
View File

@@ -1,3 +1,14 @@
module git.maximhutz.com/max/lambda module git.maximhutz.com/max/lambda
go 1.25.5 go 1.25.5
require github.com/stretchr/testify v1.11.1
require (
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/spf13/cobra v1.10.2 // indirect
github.com/spf13/pflag v1.0.9 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)

18
go.sum Normal file
View File

@@ -0,0 +1,18 @@
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

18
internal/cli/exit.go
View File

@@ -1,18 +0,0 @@
// Package "cli" provides miscellaneous helper functions.
package cli
import (
"fmt"
"os"
)
// A helper function to handle errors in the program. If it is given an error,
// the program will exist, and print the error.
func HandleError(err error) {
if err == nil {
return
}
fmt.Fprintln(os.Stderr, "ERROR:", err)
os.Exit(1)
}

11
internal/config/config.go
View File

@@ -1,11 +0,0 @@
// Package "config" parses ad handles the user settings given to the program.
package config
// Configuration settings for the program.
type Config struct {
Source Source // The source code given to the program.
Verbose bool // Whether or not to print debug logs.
Explanation bool // Whether or not to print an explanation of the reduction.
Profile string // If not nil, print a CPU profile during execution.
Statistics bool // Whether or not to print statistics.
}

23
internal/config/get_logger.go
View File

@@ -1,23 +0,0 @@
package config
import (
"log/slog"
"os"
)
// Returns a structured logger with the appropriate configurations.
func (c Config) GetLogger() *slog.Logger {
// By default, only print out errors.
level := slog.LevelError
// If the user set the output to be "VERBOSE", return the debug logs.
if c.Verbose {
level = slog.LevelInfo
}
return slog.New(
slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
Level: level,
}),
)
}

39
internal/config/parse_from_args.go
View File

@@ -1,39 +0,0 @@
package config
import (
"flag"
"fmt"
)
// Extract the program configuration from the command-line arguments.
func FromArgs() (*Config, error) {
// Relevant flags.
verbose := flag.Bool("v", false, "Verbosity. If set, the program will print logs.")
explanation := flag.Bool("x", false, "Explanation. Whether or not to show all reduction steps.")
statistics := flag.Bool("s", false, "Statistics. If set, the process will print various statistics about the run.")
profile := flag.String("p", "", "CPU profiling. If an output file is defined, the program will profile its execution and dump its results into it.")
flag.Parse()
// There must only be one input argument.
if flag.NArg() == 0 {
return nil, fmt.Errorf("no input given")
} else if flag.NArg() > 1 {
return nil, fmt.Errorf("more than 1 command-line argument")
}
// Parse source type.
var source Source
if flag.Arg(0) == "-" {
source = StdinSource{}
} else {
source = StringSource{Data: flag.Arg(0)}
}
return &Config{
Source: source,
Verbose: *verbose,
Explanation: *explanation,
Profile: *profile,
Statistics: *statistics,
}, nil
}

29
internal/config/source.go
View File

@@ -1,29 +0,0 @@
package config
import (
"io"
"os"
)
// A method of extracting input from the user.
type Source interface {
// Fetch data from this source.
Extract() (string, error)
}
// A source defined by a string.
type StringSource struct{ Data string }
func (s StringSource) Extract() (string, error) { return s.Data, nil }
// A source pulling from standard input.
type StdinSource struct{}
func (s StdinSource) Extract() (string, error) {
data, err := io.ReadAll(os.Stdin)
if err != nil {
return "", err
}
return string(data), nil
}

32
internal/engine/engine.go
View File

@@ -1,32 +0,0 @@
// Package "engine" provides an extensible interface for users to interfact with
// λ-calculus.
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.Emitter
}
// Create a new engine, given an unreduced λ-expression.
func New(config *config.Config, expression *lambda.Expression) *Engine {
return &Engine{Config: config, Expression: expression}
}
// Begin the reduction process.
func (e Engine) Run() {
e.Emit("start")
for lambda.ReduceOnce(e.Expression) {
e.Emit("step")
}
e.Emit("end")
}

32
internal/explanation/tracker.go
View File

@@ -1,32 +0,0 @@
// Package "explanation" provides a observer to gather the reasoning during the
// reduction, and present a thorough explanation to the user for each step.
package explanation
import (
"fmt"
"git.maximhutz.com/max/lambda/internal/engine"
"git.maximhutz.com/max/lambda/pkg/lambda"
)
// Track the reductions made by a reduction proess.
type Tracker struct {
process *engine.Engine
}
// Attaches a new explanation tracker to a process.
func Track(process *engine.Engine) *Tracker {
tracker := &Tracker{process: process}
process.On("start", tracker.Start)
process.On("step", tracker.Step)
return tracker
}
func (t *Tracker) Start() {
fmt.Println(lambda.Stringify(*t.process.Expression))
}
func (t *Tracker) Step() {
fmt.Println(" =", lambda.Stringify(*t.process.Expression))
}

53
internal/performance/tracker.go
View File

@@ -1,53 +0,0 @@
// Package "performance" provides a tracker to observer CPU performance during
// execution.
package performance
import (
"os"
"path/filepath"
"runtime/pprof"
)
// Observes a reduction process, and publishes a CPU performance profile on
// completion.
type Tracker struct {
File string
filePointer *os.File
Error error
}
// Create a performance tracker that outputs a profile to "file".
func Track(file string) *Tracker {
return &Tracker{File: file}
}
// Begin profiling.
func (t *Tracker) Start() {
var absPath string
absPath, t.Error = filepath.Abs(t.File)
if t.Error != nil {
return
}
t.Error = os.MkdirAll(filepath.Dir(absPath), 0777)
if t.Error != nil {
return
}
t.filePointer, t.Error = os.Create(absPath)
if t.Error != nil {
return
}
t.Error = pprof.StartCPUProfile(t.filePointer)
if t.Error != nil {
return
}
}
// Stop profiling.
func (t *Tracker) End() {
pprof.StopCPUProfile()
t.filePointer.Close()
}

28
internal/statistics/statistics.go
View File

@@ -1,28 +0,0 @@
// Package "statistics" provides a way to observer reduction speed during
// execution.
package statistics
import (
"fmt"
"strings"
)
// Statistics for a specific reduction.
type Results struct {
StepsTaken uint64 // Number of steps taken during execution.
TimeElapsed uint64 // The time (ms) taken for execution to complete.
}
// Returns the average number of operations per second of the execution.
func (r Results) OpsPerSecond() float32 {
return float32(r.StepsTaken) / (float32(r.TimeElapsed) / 1000)
}
// Format the results as a string.
func (r Results) String() string {
builder := strings.Builder{}
fmt.Fprintln(&builder, "Time Spent:", r.TimeElapsed, "ms")
fmt.Fprintln(&builder, "Steps:", r.StepsTaken)
fmt.Fprintln(&builder, "Speed:", r.OpsPerSecond(), "ops")
return builder.String()
}

36
internal/statistics/tracker.go
View File

@@ -1,36 +0,0 @@
package statistics
import (
"fmt"
"os"
"time"
)
// An observer, to track reduction performance.
type Tracker struct {
start time.Time
steps uint64
}
// Create a new reduction performance tracker.
func Track() *Tracker {
return &Tracker{}
}
func (t *Tracker) Start() {
t.start = time.Now()
t.steps = 0
}
func (t *Tracker) Step() {
t.steps++
}
func (t *Tracker) End() {
results := Results{
StepsTaken: t.steps,
TimeElapsed: uint64(time.Since(t.start).Milliseconds()),
}
fmt.Fprint(os.Stderr, results.String())
}

12
pkg/convert/saccharine_to_lambda.go
View File

@@ -3,11 +3,11 @@ package convert
import ( import (
"fmt" "fmt"
"git.maximhutz.com/max/lambda/pkg/lambda" "git.maximhutz.com/max/lambda/pkg/repr/lambda"
"git.maximhutz.com/max/lambda/pkg/saccharine" "git.maximhutz.com/max/lambda/pkg/repr/saccharine"
) )
func convertAtom(n *saccharine.Atom) lambda.Expression { func convertAtom(n *saccharine.Variable) lambda.Expression {
return lambda.NewVariable(n.Name) return lambda.NewVariable(n.Name)
} }
@@ -19,7 +19,7 @@ func convertAbstraction(n *saccharine.Abstraction) lambda.Expression {
// If the function has no parameters, it is a thunk. Lambda calculus still // If the function has no parameters, it is a thunk. Lambda calculus still
// requires _some_ parameter exists, so generate one. // requires _some_ parameter exists, so generate one.
if len(parameters) == 0 { if len(parameters) == 0 {
freeVars := lambda.GetFreeVariables(result) freeVars := result.GetFree()
freshName := lambda.GenerateFreshName(freeVars) freshName := lambda.GenerateFreshName(freeVars)
parameters = append(parameters, freshName) 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 { func reduceDeclare(s *saccharine.DeclareStatement, e lambda.Expression) lambda.Expression {
freshVar := lambda.GenerateFreshName(lambda.GetFreeVariables(e)) freshVar := lambda.GenerateFreshName(e.GetFree())
return lambda.NewApplication( return lambda.NewApplication(
lambda.NewAbstraction(freshVar, e), lambda.NewAbstraction(freshVar, e),
@@ -94,7 +94,7 @@ func convertClause(n *saccharine.Clause) lambda.Expression {
func SaccharineToLambda(n saccharine.Expression) lambda.Expression { func SaccharineToLambda(n saccharine.Expression) lambda.Expression {
switch n := n.(type) { switch n := n.(type) {
case *saccharine.Atom: case *saccharine.Variable:
return convertAtom(n) return convertAtom(n)
case *saccharine.Abstraction: case *saccharine.Abstraction:
return convertAbstraction(n) return convertAbstraction(n)

6
pkg/deltanet/deltanet.go
View File

@@ -1,6 +0,0 @@
// Package "deltanet" is a reduction strategy using ∆-nets.
package deltanet
type Graph struct {
Nodes []Node
}

94
pkg/deltanet/node.go
View File

@@ -1,94 +0,0 @@
package deltanet
/** ------------------------------------------------------------------------- */
// A connection between exactly two nodes in a graph.
type Edge struct {
A, B Node
}
// Returns all nodes the edge is connected to.
func (e Edge) GetConnections() []Node { return []Node{e.A, e.B} }
// Determines if a node is connected via this edge.
func (e Edge) IsConnected(n Node) bool { return e.A == n || e.B == n }
// Swaps an edges connected with one node, for another.
func (e *Edge) Swap(from Node, to Node) {
if e.A == from {
e.A = to
}
if e.B == from {
e.B = to
}
}
// Returns true if the edge is connected to each node via their pricniple ports.
func (e Edge) IsPrincipleEdge() bool {
return e.A.GetMainPort() == e && e.B.GetMainPort() == e
}
/** ------------------------------------------------------------------------- */
type Node interface {
// Returns the principle port that the node is attached to.
GetMainPort() Edge
// Returns all auxiliary ports that the node has. These ports are guaranteed
// to be ordered clockwise, as they would appear graphically.
GetAuxPorts() []Edge
// Returns the label of the node. May be blank.
GetLabel() string
}
/** ------------------------------------------------------------------------- */
type EraserNode struct {
Main Edge
}
func (n EraserNode) GetLabel() string { return "Ⓧ" }
func (n EraserNode) GetMainPort() Edge { return n.Main }
func (n EraserNode) GetAuxPorts() []Edge { return []Edge{} }
/** ------------------------------------------------------------------------- */
type ReplicatorNode struct {
Main Edge
Level uint
Aux []Edge
Deltas []int
}
func (n ReplicatorNode) GetLabel() string { return "" }
func (n ReplicatorNode) GetMainPort() Edge { return n.Main }
func (n ReplicatorNode) GetAuxPorts() []Edge { return n.Aux }
// Returns the level of the replicator node.
func (n ReplicatorNode) GetLevel() uint { return n.Level }
/** ------------------------------------------------------------------------- */
type FanNode struct {
Label string
Main Edge
Left, Right Edge
}
func (n FanNode) GetLabel() string { return n.Label }
func (n FanNode) GetMainPort() Edge { return n.Main }
func (n FanNode) GetAuxPorts() []Edge { return []Edge{n.Left, n.Right} }
/** ------------------------------------------------------------------------- */
type TerminalNode struct {
Label string
Main Edge
}
func (n TerminalNode) GetLabel() string { return n.Label }
func (n TerminalNode) GetMainPort() Edge { return n.Main }
func (n TerminalNode) GetAuxPorts() []Edge { return []Edge{} }
/** ------------------------------------------------------------------------- */

54
pkg/emitter/emitter.go
View File

@@ -1,54 +0,0 @@
package emitter
import "git.maximhutz.com/max/lambda/pkg/set"
type Observer struct {
fn func()
message string
emitter *Emitter
}
type Emitter struct {
listeners map[string]*set.Set[*Observer]
}
func Ignore[T any](fn func()) func(T) {
return func(T) { fn() }
}
func (e *Emitter) On(message string, fn func()) *Observer {
observer := &Observer{
fn: fn,
message: message,
emitter: e,
}
if e.listeners == nil {
e.listeners = map[string]*set.Set[*Observer]{}
}
if e.listeners[message] == nil {
e.listeners[message] = set.New[*Observer]()
}
e.listeners[message].Add(observer)
return observer
}
func (o *Observer) Off() {
if o.emitter.listeners[o.message] == nil {
return
}
o.emitter.listeners[o.message].Remove(o)
}
func (e *Emitter) Emit(message string) {
if e.listeners[message] == nil {
return
}
for listener := range *e.listeners[message] {
listener.fn()
}
}

23
pkg/engine/engine.go Normal file
View File

@@ -0,0 +1,23 @@
package engine
import (
"fmt"
"git.maximhutz.com/max/lambda/pkg/repr"
)
type Engine[R repr.Repr] interface {
Run(trace bool, count int) (Trace, bool)
Step() uint64
State() (repr.Repr, error)
fmt.Stringer
}
type Trace interface {
Before() string
After() string
Step() uint64
TransitionName() string
TransitionNodes() string
}

35
pkg/fifo/fifo.go
View File

@@ -1,35 +0,0 @@
package fifo
import "fmt"
type FIFO[T any] []T
func New[T any](items ...T) *FIFO[T] {
f := FIFO[T](items)
return &f
}
func (f *FIFO[T]) Push(item T) {
*f = append(*f, item)
}
func (f *FIFO[T]) Empty() bool {
return len(*f) == 0
}
func (f *FIFO[T]) MustPop() T {
var item T
*f, item = (*f)[:len(*f)-1], (*f)[len(*f)-1]
return item
}
func (f *FIFO[T]) Pop() (T, error) {
var item T
if f.Empty() {
return item, fmt.Errorf("stack is exhausted")
}
return f.MustPop(), nil
}

70
pkg/lambda/expression.go
View File

@@ -1,70 +0,0 @@
package lambda
type Expression interface {
Accept(Visitor)
Copy() Expression
}
/** ------------------------------------------------------------------------- */
type Abstraction struct {
Parameter string
Body Expression
}
func (a *Abstraction) Copy() Expression {
return NewAbstraction(a.Parameter, a.Body.Copy())
}
func (a *Abstraction) Accept(v Visitor) {
v.VisitAbstraction(a)
}
func NewAbstraction(parameter string, body Expression) *Abstraction {
return &Abstraction{Parameter: parameter, Body: body}
}
/** ------------------------------------------------------------------------- */
type Application struct {
Abstraction Expression
Argument Expression
}
func (a *Application) Copy() Expression {
return NewApplication(a.Abstraction.Copy(), a.Argument.Copy())
}
func (a *Application) Accept(v Visitor) {
v.VisitApplication(a)
}
func NewApplication(function Expression, argument Expression) *Application {
return &Application{Abstraction: function, Argument: argument}
}
/** ------------------------------------------------------------------------- */
type Variable struct {
Value string
}
func (v *Variable) Copy() Expression {
return NewVariable(v.Value)
}
func (v *Variable) Accept(visitor Visitor) {
visitor.VisitVariable(v)
}
func NewVariable(name string) *Variable {
return &Variable{Value: name}
}
/** ------------------------------------------------------------------------- */
type Visitor interface {
VisitAbstraction(*Abstraction)
VisitApplication(*Application)
VisitVariable(*Variable)
}

20
pkg/lambda/get_free_variables.go
View File

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

14
pkg/lambda/is_free_variable.go
View File

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

27
pkg/lambda/reduce.go
View File

@@ -1,27 +0,0 @@
package lambda
import "git.maximhutz.com/max/lambda/pkg/fifo"
func ReduceOnce(e *Expression) bool {
stack := fifo.New(e)
for !stack.Empty() {
top := stack.MustPop()
switch typed := (*top).(type) {
case *Abstraction:
stack.Push(&typed.Body)
case *Application:
if fn, fnOk := typed.Abstraction.(*Abstraction); fnOk {
Substitute(&fn.Body, fn.Parameter, typed.Argument)
*top = fn.Body
return true
}
stack.Push(&typed.Argument)
stack.Push(&typed.Abstraction)
}
}
return false
}

19
pkg/lambda/rename.go
View File

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

32
pkg/lambda/stringify.go
View File

@@ -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()
}

27
pkg/lambda/substitute.go
View File

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

87
pkg/repr/lambda/expression.go Normal file
View File

@@ -0,0 +1,87 @@
package lambda
import (
"git.maximhutz.com/max/lambda/pkg/repr"
"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 {
repr.Repr
// 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
}
var (
_ Expression = Abstraction{}
_ Expression = Application{}
_ Expression = Variable{}
)
/** ------------------------------------------------------------------------- */
type Abstraction struct {
parameter string
body Expression
}
func (a Abstraction) Parameter() string {
return a.parameter
}
func (a Abstraction) Body() Expression {
return a.body
}
func NewAbstraction(parameter string, body Expression) Abstraction {
return Abstraction{parameter, body}
}
/** ------------------------------------------------------------------------- */
type Application struct {
abstraction Expression
argument Expression
}
func (a Application) Abstraction() Expression {
return a.abstraction
}
func (a Application) Argument() Expression {
return a.argument
}
func NewApplication(abstraction Expression, argument Expression) Application {
return Application{abstraction, argument}
}
/** ------------------------------------------------------------------------- */
type Variable struct {
name string
}
func (v Variable) Name() string {
return v.name
}
func NewVariable(name string) Variable {
return Variable{name}
}

4
pkg/lambda/generate_name.go → pkg/repr/lambda/generate_name.go
View File

@@ -6,7 +6,9 @@ import (
"git.maximhutz.com/max/lambda/pkg/set" "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++ { for i := uint64(0); ; i++ {
attempt := "_" + string(strconv.AppendUint(nil, i, 10)) attempt := "_" + string(strconv.AppendUint(nil, i, 10))

19
pkg/repr/lambda/get_free_variables.go Normal file
View File

@@ -0,0 +1,19 @@
package lambda
import "git.maximhutz.com/max/lambda/pkg/set"
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
}

12
pkg/repr/lambda/is_free_variable.go Normal file
View File

@@ -0,0 +1,12 @@
package lambda
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)
}

28
pkg/repr/lambda/rename.go Normal file
View File

@@ -0,0 +1,28 @@
package lambda
// 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
}
func (e Abstraction) Rename(target string, newName string) Expression {
newParam := e.Parameter()
if e.Parameter() == target {
newParam = newName
}
newBody := e.Body().Rename(target, newName)
return NewAbstraction(newParam, newBody)
}
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)
}

35
pkg/repr/lambda/substitute.go Normal file
View File

@@ -0,0 +1,35 @@
package lambda
func (e Variable) Substitute(target string, replacement Expression) Expression {
if e.Name() == target {
return replacement
}
return e
}
func (e Abstraction) Substitute(target string, replacement Expression) Expression {
if e.Parameter() == target {
return e
}
body := e.Body()
param := e.Parameter()
if replacement.IsFree(param) {
freeVars := replacement.GetFree()
freeVars.Merge(body.GetFree())
freshVar := GenerateFreshName(freeVars)
body = body.Rename(param, freshVar)
param = freshVar
}
newBody := body.Substitute(target, replacement)
return NewAbstraction(param, newBody)
}
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)
}

4
pkg/repr/repr.go Normal file
View File

@@ -0,0 +1,4 @@
package repr
type Repr interface {
}

54
pkg/saccharine/expression.go → pkg/repr/saccharine/expression.go
View File

@@ -1,9 +1,20 @@
package saccharine package saccharine
import (
"git.maximhutz.com/max/lambda/pkg/repr"
)
type Expression interface { type Expression interface {
IsExpression() repr.Repr
} }
var (
_ Expression = Abstraction{}
_ Expression = Application{}
_ Expression = Variable{}
_ Expression = Clause{}
)
/** ------------------------------------------------------------------------- */ /** ------------------------------------------------------------------------- */
type Abstraction struct { type Abstraction struct {
@@ -11,37 +22,36 @@ type Abstraction struct {
Body Expression Body Expression
} }
type Application struct { func NewAbstraction(parameter []string, body Expression) *Abstraction {
Abstraction Expression return &Abstraction{Parameters: parameter, Body: body}
Arguments []Expression
} }
type Atom struct {
Name string
}
type Clause struct {
Statements []Statement
Returns Expression
}
func (Abstraction) IsExpression() {}
func (Application) IsExpression() {}
func (Atom) IsExpression() {}
func (Clause) IsExpression() {}
/** ------------------------------------------------------------------------- */ /** ------------------------------------------------------------------------- */
func NewAbstraction(parameter []string, body Expression) *Abstraction { type Application struct {
return &Abstraction{Parameters: parameter, Body: body} Abstraction Expression
Arguments []Expression
} }
func NewApplication(abstraction Expression, arguments []Expression) *Application { func NewApplication(abstraction Expression, arguments []Expression) *Application {
return &Application{Abstraction: abstraction, Arguments: arguments} return &Application{Abstraction: abstraction, Arguments: arguments}
} }
func NewAtom(name string) *Atom { /** ------------------------------------------------------------------------- */
return &Atom{Name: name}
type Variable struct {
Name string
}
func NewVariable(name string) *Variable {
return &Variable{Name: name}
}
/** ------------------------------------------------------------------------- */
type Clause struct {
Statements []Statement
Returns Expression
} }
func NewClause(statements []Statement, returns Expression) *Clause { func NewClause(statements []Statement, returns Expression) *Clause {

63
pkg/saccharine/parse.go → pkg/repr/saccharine/parse.go
View File

@@ -5,18 +5,17 @@ import (
"fmt" "fmt"
"git.maximhutz.com/max/lambda/pkg/iterator" "git.maximhutz.com/max/lambda/pkg/iterator"
"git.maximhutz.com/max/lambda/pkg/saccharine/token"
"git.maximhutz.com/max/lambda/pkg/trace" "git.maximhutz.com/max/lambda/pkg/trace"
) )
type TokenIterator = iterator.Iterator[token.Token] type TokenIterator = iterator.Iterator[Token]
func parseRawToken(i *TokenIterator, expected token.Type) (*token.Token, error) { func parseRawToken(i *TokenIterator, expected Type) (*Token, error) {
return iterator.Do(i, func(i *TokenIterator) (*token.Token, error) { return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
if tok, err := i.Next(); err != nil { if tok, err := i.Next(); err != nil {
return nil, err return nil, err
} else if tok.Type != expected { } else if tok.Type != expected {
return nil, fmt.Errorf("expected token %v, got %v'", token.Name(expected), tok.Value) return nil, fmt.Errorf("expected token %v, got %v'", Name(expected), tok.Value)
} else { } else {
return &tok, nil return &tok, nil
} }
@@ -25,14 +24,14 @@ func parseRawToken(i *TokenIterator, expected token.Type) (*token.Token, error)
func passSoftBreaks(i *TokenIterator) { func passSoftBreaks(i *TokenIterator) {
for { for {
if _, err := parseRawToken(i, token.SoftBreak); err != nil { if _, err := parseRawToken(i, TokenSoftBreak); err != nil {
return return
} }
} }
} }
func parseToken(i *TokenIterator, expected token.Type, ignoreSoftBreaks bool) (*token.Token, error) { func parseToken(i *TokenIterator, expected Type, ignoreSoftBreaks bool) (*Token, error) {
return iterator.Do(i, func(i *TokenIterator) (*token.Token, error) { return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
if ignoreSoftBreaks { if ignoreSoftBreaks {
passSoftBreaks(i) passSoftBreaks(i)
} }
@@ -42,17 +41,17 @@ func parseToken(i *TokenIterator, expected token.Type, ignoreSoftBreaks bool) (*
} }
func parseString(i *TokenIterator) (string, error) { func parseString(i *TokenIterator) (string, error) {
if tok, err := parseToken(i, token.Atom, true); err != nil { if tok, err := parseToken(i, TokenAtom, true); err != nil {
return "", trace.Wrap(err, "no variable (col %d)", i.Index()) return "", trace.Wrap(err, "no variable (col %d)", i.Index())
} else { } else {
return tok.Value, nil return tok.Value, nil
} }
} }
func parseBreak(i *TokenIterator) (*token.Token, error) { func parseBreak(i *TokenIterator) (*Token, error) {
if tok, softErr := parseRawToken(i, token.SoftBreak); softErr == nil { if tok, softErr := parseRawToken(i, TokenSoftBreak); softErr == nil {
return tok, nil return tok, nil
} else if tok, hardErr := parseRawToken(i, token.HardBreak); hardErr == nil { } else if tok, hardErr := parseRawToken(i, TokenHardBreak); hardErr == nil {
return tok, nil return tok, nil
} else { } else {
return nil, errors.Join(softErr, hardErr) return nil, errors.Join(softErr, hardErr)
@@ -76,11 +75,11 @@ func parseList[U any](i *TokenIterator, fn func(*TokenIterator) (U, error), mini
func parseAbstraction(i *TokenIterator) (*Abstraction, error) { func parseAbstraction(i *TokenIterator) (*Abstraction, error) {
return iterator.Do(i, func(i *TokenIterator) (*Abstraction, error) { return iterator.Do(i, func(i *TokenIterator) (*Abstraction, error) {
if _, err := parseToken(i, token.Slash, true); err != nil { if _, err := parseToken(i, TokenSlash, true); err != nil {
return nil, trace.Wrap(err, "no function slash (col %d)", i.MustGet().Column) return nil, trace.Wrap(err, "no function slash (col %d)", i.MustGet().Column)
} else if parameters, err := parseList(i, parseString, 0); err != nil { } else if parameters, err := parseList(i, parseString, 0); err != nil {
return nil, err return nil, err
} else if _, err = parseToken(i, token.Dot, true); err != nil { } else if _, err = parseToken(i, TokenDot, true); err != nil {
return nil, trace.Wrap(err, "no function dot (col %d)", i.MustGet().Column) return nil, trace.Wrap(err, "no function dot (col %d)", i.MustGet().Column)
} else if body, err := parseExpression(i); err != nil { } else if body, err := parseExpression(i); err != nil {
return nil, err return nil, err
@@ -92,11 +91,11 @@ func parseAbstraction(i *TokenIterator) (*Abstraction, error) {
func parseApplication(i *TokenIterator) (*Application, error) { func parseApplication(i *TokenIterator) (*Application, error) {
return iterator.Do(i, func(i *TokenIterator) (*Application, error) { return iterator.Do(i, func(i *TokenIterator) (*Application, error) {
if _, err := parseToken(i, token.OpenParen, true); err != nil { if _, err := parseToken(i, TokenOpenParen, true); err != nil {
return nil, trace.Wrap(err, "no openning brackets (col %d)", i.MustGet().Column) return nil, trace.Wrap(err, "no openning brackets (col %d)", i.MustGet().Column)
} else if expressions, err := parseList(i, parseExpression, 1); err != nil { } else if expressions, err := parseList(i, parseExpression, 1); err != nil {
return nil, err return nil, err
} else if _, err := parseToken(i, token.CloseParen, true); err != nil { } else if _, err := parseToken(i, TokenCloseParen, true); err != nil {
return nil, trace.Wrap(err, "no closing brackets (col %d)", i.MustGet().Column) return nil, trace.Wrap(err, "no closing brackets (col %d)", i.MustGet().Column)
} else { } else {
return NewApplication(expressions[0], expressions[1:]), nil return NewApplication(expressions[0], expressions[1:]), nil
@@ -104,11 +103,11 @@ func parseApplication(i *TokenIterator) (*Application, error) {
}) })
} }
func parseAtom(i *TokenIterator) (*Atom, error) { func parseAtom(i *TokenIterator) (*Variable, error) {
if tok, err := parseToken(i, token.Atom, true); err != nil { if tok, err := parseToken(i, TokenAtom, true); err != nil {
return nil, trace.Wrap(err, "no variable (col %d)", i.Index()) return nil, trace.Wrap(err, "no variable (col %d)", i.Index())
} else { } else {
return NewAtom(tok.Value), nil return NewVariable(tok.Value), nil
} }
} }
@@ -133,7 +132,7 @@ func parseStatements(i *TokenIterator) ([]Statement, error) {
func parseClause(i *TokenIterator, braces bool) (*Clause, error) { func parseClause(i *TokenIterator, braces bool) (*Clause, error) {
if braces { if braces {
if _, err := parseToken(i, token.OpenBrace, true); err != nil { if _, err := parseToken(i, TokenOpenBrace, true); err != nil {
return nil, err return nil, err
} }
} }
@@ -152,7 +151,7 @@ func parseClause(i *TokenIterator, braces bool) (*Clause, error) {
} }
if braces { if braces {
if _, err := parseToken(i, token.CloseBrace, true); err != nil { if _, err := parseToken(i, TokenCloseBrace, true); err != nil {
return nil, err return nil, err
} }
} }
@@ -165,13 +164,13 @@ func parseExpression(i *TokenIterator) (Expression, error) {
passSoftBreaks(i) passSoftBreaks(i)
switch peek := i.MustGet(); peek.Type { switch peek := i.MustGet(); peek.Type {
case token.OpenParen: case TokenOpenParen:
return parseApplication(i) return parseApplication(i)
case token.Slash: case TokenSlash:
return parseAbstraction(i) return parseAbstraction(i)
case token.Atom: case TokenAtom:
return parseAtom(i) return parseAtom(i)
case token.OpenBrace: case TokenOpenBrace:
return parseClause(i, true) return parseClause(i, true)
default: default:
return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column) return nil, fmt.Errorf("expected expression, got '%v' (col %d)", peek.Value, peek.Column)
@@ -183,7 +182,7 @@ func parseLet(i *TokenIterator) (*LetStatement, error) {
return iterator.Do(i, func(i *TokenIterator) (*LetStatement, error) { return iterator.Do(i, func(i *TokenIterator) (*LetStatement, error) {
if parameters, err := parseList(i, parseString, 1); err != nil { if parameters, err := parseList(i, parseString, 1); err != nil {
return nil, err return nil, err
} else if _, err := parseToken(i, token.Assign, true); err != nil { } else if _, err := parseToken(i, TokenAssign, true); err != nil {
return nil, err return nil, err
} else if body, err := parseExpression(i); err != nil { } else if body, err := parseExpression(i); err != nil {
return nil, err return nil, err
@@ -212,7 +211,7 @@ func parseStatement(i *TokenIterator) (Statement, error) {
} }
// Given a list of tokens, attempt to parse it into an syntax tree. // Given a list of tokens, attempt to parse it into an syntax tree.
func parse(tokens []token.Token) (Expression, error) { func parse(tokens []Token) (Expression, error) {
i := iterator.Of(tokens) i := iterator.Of(tokens)
exp, err := parseClause(i, false) exp, err := parseClause(i, false)
@@ -226,3 +225,13 @@ func parse(tokens []token.Token) (Expression, error) {
return exp, nil return exp, nil
} }
// Convert a piece of valid saccharine code into an expression.
func Parse(code string) (Expression, error) {
tokens, err := Scan(code)
if err != nil {
return nil, err
}
return parse(tokens)
}

31
pkg/saccharine/token/parse.go → pkg/repr/saccharine/scan.go
View File

@@ -1,4 +1,4 @@
package token package saccharine
import ( import (
"errors" "errors"
@@ -14,7 +14,7 @@ func isVariable(r rune) bool {
return unicode.IsLetter(r) || unicode.IsNumber(r) return unicode.IsLetter(r) || unicode.IsNumber(r)
} }
func parseRune(i *iterator.Iterator[rune], expected func(rune) bool) (rune, error) { func scanRune(i *iterator.Iterator[rune], expected func(rune) bool) (rune, error) {
i2 := i.Copy() i2 := i.Copy()
if r, err := i2.Next(); err != nil { if r, err := i2.Next(); err != nil {
@@ -27,7 +27,7 @@ func parseRune(i *iterator.Iterator[rune], expected func(rune) bool) (rune, erro
} }
} }
func parseCharacter(i *iterator.Iterator[rune], expected rune) (rune, error) { func scanCharacter(i *iterator.Iterator[rune], expected rune) (rune, error) {
i2 := i.Copy() i2 := i.Copy()
if r, err := i2.Next(); err != nil { if r, err := i2.Next(); err != nil {
@@ -42,7 +42,7 @@ func parseCharacter(i *iterator.Iterator[rune], expected rune) (rune, error) {
// Pulls the next token from an iterator over runes. If it cannot, it will // Pulls the next token from an iterator over runes. If it cannot, it will
// return nil. If an error occurs, it will return that. // return nil. If an error occurs, it will return that.
func getToken(i *iterator.Iterator[rune]) (*Token, error) { func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
index := i.Index() index := i.Index()
if i.Done() { if i.Done() {
@@ -70,20 +70,35 @@ func getToken(i *iterator.Iterator[rune]) (*Token, error) {
case letter == '}': case letter == '}':
return NewCloseBrace(index), nil return NewCloseBrace(index), nil
case letter == ':': case letter == ':':
if _, err := parseCharacter(i, '='); err != nil { if _, err := scanCharacter(i, '='); err != nil {
return nil, err return nil, err
} else { } else {
return NewAssign(index), nil return NewAssign(index), nil
} }
case letter == ';': case letter == ';':
return NewHardBreak(index), nil return NewHardBreak(index), nil
case letter == '#':
// Skip everything until the next newline or EOF.
for !i.Done() {
r, err := i.Next()
if err != nil {
return nil, trace.Wrap(err, "error while parsing comment")
}
if r == '\n' {
// Put the newline back so it can be processed as a soft break.
i.Back()
break
}
}
return nil, nil
case unicode.IsSpace(letter): case unicode.IsSpace(letter):
return nil, nil return nil, nil
case isVariable(letter): case isVariable(letter):
atom := []rune{letter} atom := []rune{letter}
for { for {
if r, err := parseRune(i, isVariable); err != nil { if r, err := scanRune(i, isVariable); err != nil {
break break
} else { } else {
atom = append(atom, r) atom = append(atom, r)
@@ -97,13 +112,13 @@ func getToken(i *iterator.Iterator[rune]) (*Token, error) {
} }
// Parse a string into tokens. // Parse a string into tokens.
func Parse(input string) ([]Token, error) { func Scan(input string) ([]Token, error) {
i := iterator.Of([]rune(input)) i := iterator.Of([]rune(input))
tokens := []Token{} tokens := []Token{}
errorList := []error{} errorList := []error{}
for !i.Done() { for !i.Done() {
token, err := getToken(i) token, err := scanToken(i)
if err != nil { if err != nil {
errorList = append(errorList, err) errorList = append(errorList, err)
} else if token != nil { } else if token != nil {

17
pkg/saccharine/statement.go → pkg/repr/saccharine/statement.go
View File

@@ -1,7 +1,11 @@
package saccharine package saccharine
import (
"git.maximhutz.com/max/lambda/pkg/repr"
)
type Statement interface { type Statement interface {
IsStatement() repr.Repr
} }
/** ------------------------------------------------------------------------- */ /** ------------------------------------------------------------------------- */
@@ -12,17 +16,14 @@ type LetStatement struct {
Body Expression Body Expression
} }
type DeclareStatement struct { func NewLet(name string, parameters []string, body Expression) *LetStatement {
Value Expression return &LetStatement{Name: name, Parameters: parameters, Body: body}
} }
func (LetStatement) IsStatement() {}
func (DeclareStatement) IsStatement() {}
/** ------------------------------------------------------------------------- */ /** ------------------------------------------------------------------------- */
func NewLet(name string, parameters []string, body Expression) *LetStatement { type DeclareStatement struct {
return &LetStatement{Name: name, Parameters: parameters, Body: body} Value Expression
} }
func NewDeclare(value Expression) *DeclareStatement { func NewDeclare(value Expression) *DeclareStatement {

18
pkg/saccharine/stringify.go → pkg/repr/saccharine/stringify.go
View File

@@ -5,30 +5,30 @@ import (
"strings" "strings"
) )
func stringifyAtom(n *Atom) string { func stringifyAtom(n *Variable) string {
return n.Name return n.Name
} }
func stringifyAbstraction(n *Abstraction) string { func stringifyAbstraction(n *Abstraction) string {
return "\\" + strings.Join(n.Parameters, " ") + "." + stringifyExpression(n.Body) return "\\" + strings.Join(n.Parameters, " ") + "." + Stringify(n.Body)
} }
func stringifyApplication(n *Application) string { func stringifyApplication(n *Application) string {
arguments := []string{stringifyExpression(n.Abstraction)} arguments := []string{Stringify(n.Abstraction)}
for _, argument := range n.Arguments { for _, argument := range n.Arguments {
arguments = append(arguments, stringifyExpression(argument)) arguments = append(arguments, Stringify(argument))
} }
return "(" + strings.Join(arguments, " ") + ")" return "(" + strings.Join(arguments, " ") + ")"
} }
func stringifyLet(s *LetStatement) string { func stringifyLet(s *LetStatement) string {
return s.Name + " " + strings.Join(s.Parameters, " ") + " := " + stringifyExpression(s.Body) return s.Name + " " + strings.Join(s.Parameters, " ") + " := " + Stringify(s.Body)
} }
func stringifyDeclare(s *DeclareStatement) string { func stringifyDeclare(s *DeclareStatement) string {
return stringifyExpression(s.Value) return Stringify(s.Value)
} }
func stringifyStatement(s Statement) string { func stringifyStatement(s Statement) string {
@@ -49,13 +49,13 @@ func stringifyClause(n *Clause) string {
stmts += stringifyStatement(statement) + "; " stmts += stringifyStatement(statement) + "; "
} }
return "{ " + stmts + stringifyExpression(n.Returns) + " }" return "{ " + stmts + Stringify(n.Returns) + " }"
} }
// Convert an expression back into valid source code. // Convert an expression back into valid source code.
func stringifyExpression(n Expression) string { func Stringify(n Expression) string {
switch n := n.(type) { switch n := n.(type) {
case *Atom: case *Variable:
return stringifyAtom(n) return stringifyAtom(n)
case *Abstraction: case *Abstraction:
return stringifyAbstraction(n) return stringifyAbstraction(n)

91
pkg/repr/saccharine/token.go Normal file
View File

@@ -0,0 +1,91 @@
package saccharine
import "fmt"
// All tokens in the pseudo-lambda language.
type Type int
const (
TokenOpenParen Type = iota // Denotes the '(' token.
TokenCloseParen // Denotes the ')' token.
TokenOpenBrace // Denotes the '{' token.
TokenCloseBrace // Denotes the '}' token.
TokenHardBreak // Denotes the ';' token.
TokenAssign // Denotes the ':=' token.
TokenAtom // Denotes an alpha-numeric variable.
TokenSlash // Denotes the '/' token.
TokenDot // Denotes the '.' token.
TokenSoftBreak // Denotes a new-line.
)
// A representation of a token in source code.
type Token struct {
Column int // Where the token begins in the source text.
Type Type // What type the token is.
Value string // The value of the token.
}
func NewOpenParen(column int) *Token {
return &Token{Type: TokenOpenParen, Column: column, Value: "("}
}
func NewCloseParen(column int) *Token {
return &Token{Type: TokenCloseParen, Column: column, Value: ")"}
}
func NewOpenBrace(column int) *Token {
return &Token{Type: TokenOpenBrace, Column: column, Value: "{"}
}
func NewCloseBrace(column int) *Token {
return &Token{Type: TokenCloseBrace, Column: column, Value: "}"}
}
func NewDot(column int) *Token {
return &Token{Type: TokenDot, Column: column, Value: "."}
}
func NewHardBreak(column int) *Token {
return &Token{Type: TokenHardBreak, Column: column, Value: ";"}
}
func NewAssign(column int) *Token {
return &Token{Type: TokenAssign, Column: column, Value: ":="}
}
func NewSlash(column int) *Token {
return &Token{Type: TokenSlash, Column: column, Value: "\\"}
}
func NewAtom(name string, column int) *Token {
return &Token{Type: TokenAtom, Column: column, Value: name}
}
func NewSoftBreak(column int) *Token {
return &Token{Type: TokenSoftBreak, Column: column, Value: "\\n"}
}
func Name(typ Type) string {
switch typ {
case TokenOpenParen:
return "("
case TokenCloseParen:
return ")"
case TokenSlash:
return "\\"
case TokenDot:
return "."
case TokenAtom:
return "ATOM"
case TokenSoftBreak:
return "\\n"
case TokenHardBreak:
return ";"
default:
panic(fmt.Errorf("unknown token type %v", typ))
}
}
func (t Token) Name() string {
return Name(t.Type)
}

22
pkg/saccharine/saccharine.go
View File

@@ -1,22 +0,0 @@
// Package "saccharine" provides a simple language built on top of λ-calculus,
// to facilitate productive coding using it.
package saccharine
import (
"git.maximhutz.com/max/lambda/pkg/saccharine/token"
)
// Convert a piece of valid saccharine code into an expression.
func Parse(code string) (Expression, error) {
tokens, err := token.Parse(code)
if err != nil {
return nil, err
}
return parse(tokens)
}
// Convert a parsed saccharine expression back into source code.
func Stringify(expression Expression) string {
return stringifyExpression(expression)
}

91
pkg/saccharine/token/token.go
View File

@@ -1,91 +0,0 @@
package token
import "fmt"
// All tokens in the pseudo-lambda language.
type Type int
const (
OpenParen Type = iota // Denotes the '(' token.
CloseParen // Denotes the ')' token.
OpenBrace // Denotes the '{' token.
CloseBrace // Denotes the '}' token.
HardBreak // Denotes the ';' token.
Assign // Denotes the ':=' token.
Atom // Denotes an alpha-numeric variable.
Slash // Denotes the '/' token.
Dot // Denotes the '.' token.
SoftBreak // Denotes a new-line.
)
// A representation of a token in source code.
type Token struct {
Column int // Where the token begins in the source text.
Type Type // What type the token is.
Value string // The value of the token.
}
func NewOpenParen(column int) *Token {
return &Token{Type: OpenParen, Column: column, Value: "("}
}
func NewCloseParen(column int) *Token {
return &Token{Type: CloseParen, Column: column, Value: ")"}
}
func NewOpenBrace(column int) *Token {
return &Token{Type: OpenBrace, Column: column, Value: "{"}
}
func NewCloseBrace(column int) *Token {
return &Token{Type: CloseBrace, Column: column, Value: "}"}
}
func NewDot(column int) *Token {
return &Token{Type: Dot, Column: column, Value: "."}
}
func NewHardBreak(column int) *Token {
return &Token{Type: HardBreak, Column: column, Value: ";"}
}
func NewAssign(column int) *Token {
return &Token{Type: Assign, Column: column, Value: ":="}
}
func NewSlash(column int) *Token {
return &Token{Type: Slash, Column: column, Value: "\\"}
}
func NewAtom(name string, column int) *Token {
return &Token{Type: Atom, Column: column, Value: name}
}
func NewSoftBreak(column int) *Token {
return &Token{Type: SoftBreak, Column: column, Value: "\\n"}
}
func Name(typ Type) string {
switch typ {
case OpenParen:
return "("
case CloseParen:
return ")"
case Slash:
return "\\"
case Dot:
return "."
case Atom:
return "ATOM"
case SoftBreak:
return "\\n"
case HardBreak:
return ";"
default:
panic(fmt.Errorf("unknown token type %v", typ))
}
}
func (t Token) Name() string {
return Name(t.Type)
}

28
pkg/set/set.go
View File

@@ -1,10 +1,12 @@
package set package set
import "iter"
type Set[T comparable] map[T]bool 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 { for _, item := range items {
(*s)[item] = true s[item] = true
} }
} }
@@ -12,14 +14,14 @@ func (s Set[T]) Has(item T) bool {
return s[item] return s[item]
} }
func (s *Set[T]) Remove(items ...T) { func (s Set[T]) Remove(items ...T) {
for _, item := range items { for _, item := range items {
delete(*s, item) delete(s, item)
} }
} }
func (s *Set[T]) Merge(o *Set[T]) { func (s Set[T]) Merge(o Set[T]) {
for item := range *o { for item := range o {
s.Add(item) s.Add(item)
} }
} }
@@ -34,8 +36,18 @@ func (s Set[T]) ToList() []T {
return list return list
} }
func New[T comparable](items ...T) *Set[T] { func (s Set[T]) Items() iter.Seq[T] {
result := &Set[T]{} return func(yield func(T) bool) {
for item := range s {
if !yield(item) {
return
}
}
}
}
func New[T comparable](items ...T) Set[T] {
result := Set[T]{}
for _, item := range items { for _, item := range items {
result.Add(item) result.Add(item)

16
samples/simple.txt
View File

@@ -1,16 +0,0 @@
(\0.
(\inc.
(\add.
(\mult.
(\exp.
(exp (inc (inc (inc (inc 0)))) (inc (inc (inc (inc (inc 0))))))
\n m.(m n)
)
\m n f.(m (n f))
)
\n m.(m inc n)
)
\n f x.(f (n f x))
)
\f x.x
)

1
tests/church_5^5.expected Normal file
View File

File diff suppressed because one or more lines are too long

3
samples/church.txt → tests/church_5^5.test
View File

@@ -1,7 +1,8 @@
0 := \f.\x.x 0 := \f.\x.x
inc n := \f x.(f (n f x)) inc n := \f x.(f (n f x))
exp n m := (m n) exp n m := (m n)
print n := (n F X)
N := (inc (inc (inc (inc (inc 0))))) N := (inc (inc (inc (inc (inc 0)))))
(exp N N) (print (exp N N))

1
tests/comments.expected Normal file
View File

@@ -0,0 +1 @@
VALUE

17
tests/comments.test Normal file
View File

@@ -0,0 +1,17 @@
# This is a full-line comment at the start
# The following defines the identity function
identity := \x.x # This is an end-of-line comment
# Define a simple function that applies a function twice
twice := \f.\x.(f
# Comments can be anywhere!
(f x))
# Test that comments don't interfere with expressions
result := (twice identity VALUE) # Should just return VALUE
# Multiple comments in a row
# can appear anywhere
# without breaking the code
result # Final comment at the end

1
tests/fast_list_2^30.expected Normal file
View File

@@ -0,0 +1 @@
(0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (1 END)))))))))))))))))))))))))))))))

0
samples/fast.txt → tests/fast_list_2^30.test
View File

1
tests/list_2^30.expected Normal file
View File

@@ -0,0 +1 @@
(0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (0 (1 END)))))))))))))))))))))))))))))))

0
samples/saccharine.txt → tests/list_2^30.test
View File

1
tests/thunk.expected Normal file
View File

@@ -0,0 +1 @@
VALUE

0
samples/thunk.txt → tests/thunk.test
View File