Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/ljedrz/lambda_calculus
A simple, zero-dependency implementation of the untyped lambda calculus in Safe Rust
https://github.com/ljedrz/lambda_calculus
beta-reduction church-encoding combinatory-logic debruijn embedded-iterators-encoding lambda-calculus lambda-expressions lambda-functions lambda-interpreter parigot-encoding reduction-strategies rust rust-library scott-encoding ski-combinators stump-fu-encoding
Last synced: 3 days ago
JSON representation
A simple, zero-dependency implementation of the untyped lambda calculus in Safe Rust
- Host: GitHub
- URL: https://github.com/ljedrz/lambda_calculus
- Owner: ljedrz
- License: cc0-1.0
- Created: 2017-04-05T12:00:25.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2024-07-23T08:59:57.000Z (4 months ago)
- Last Synced: 2024-10-29T11:13:56.440Z (19 days ago)
- Topics: beta-reduction, church-encoding, combinatory-logic, debruijn, embedded-iterators-encoding, lambda-calculus, lambda-expressions, lambda-functions, lambda-interpreter, parigot-encoding, reduction-strategies, rust, rust-library, scott-encoding, ski-combinators, stump-fu-encoding
- Language: Rust
- Homepage:
- Size: 652 KB
- Stars: 113
- Watchers: 4
- Forks: 10
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
- awesome-rust-formalized-reasoning - lambda_calculus - simple, zero-dependency implementation of pure lambda calculus in safe Rust. (Lambda Calculus / Libraries)
README
# lambda_calculus
[](https://creativecommons.org/publicdomain/zero/1.0/)
[](https://crates.io/crates/lambda_calculus)
[](https://docs.rs/lambda_calculus)
[](https://gist.github.com/cheerfulstoic/d107229326a01ff0f333a1d3476e068d)
**lambda_calculus** is a simple, zero-dependency implementation of pure lambda calculus in Safe Rust.
## Features
- a parser for lambda expressions, both in classic and De Bruijn index notation
- 7 β-reduction strategies
- a set of standard terms (combinators)
- lambda-encoded boolean, pair, tuple, option and result data types
- single-pair-encoded list
- Church-, Scott- and Parigot-encoded numerals and lists
- Stump-Fu (embedded iterators)- and binary-encoded numerals
- signed numbers
## Installation
Include the library by adding the following to your Cargo.toml:
```toml
[dependencies]
lambda_calculus = "3"
```
Compilation features:
- `backslash_lambda`: changes the display of lambdas from `λ` to `\`
- `encoding`: builds the data encoding modules; default feature
Example feature setup in Cargo.toml:
```toml
[dependencies.lambda_calculus]
version = "3"
default-features = false # do not build the data encoding modules
features = ["backslash_lambda"] # use a backslash lambda
```
## Examples
### Comparing classic and De Bruijn index notation
code:
```rust
use lambda_calculus::data::num::church::{succ, pred};
fn main() {
println!("SUCC := {0} = {0:?}", succ());
println!("PRED := {0} = {0:?}", pred());
}
```
stdout:
```
SUCC := λa.λb.λc.b (a b c) = λλλ2(321)
PRED := λa.λb.λc.a (λd.λe.e (d b)) (λd.c) (λd.d) = λλλ3(λλ1(24))(λ2)(λ1)
```
### Parsing lambda expressions
code:
```rust
use lambda_calculus::*;
fn main() {
assert_eq!(
parse(&"λa.λb.λc.b (a b c)", Classic),
parse(&"λλλ2(321)", DeBruijn)
);
}
```
### Showing β-reduction steps
code:
```rust
use lambda_calculus::*;
use lambda_calculus::data::num::church::pred;
fn main() {
let mut expr = app!(pred(), 1.into_church());
println!("{} order β-reduction steps for PRED 1 are:", NOR);
println!("{}", expr);
while expr.reduce(NOR, 1) != 0 {
println!("{}", expr);
}
}
```
stdout:
```
normal order β-reduction steps for PRED 1 are:
(λa.λb.λc.a (λd.λe.e (d b)) (λd.c) (λd.d)) (λa.λb.a b)
λa.λb.(λc.λd.c d) (λc.λd.d (c a)) (λc.b) (λc.c)
λa.λb.(λc.(λd.λe.e (d a)) c) (λc.b) (λc.c)
λa.λb.(λc.λd.d (c a)) (λc.b) (λc.c)
λa.λb.(λc.c ((λd.b) a)) (λc.c)
λa.λb.(λc.c) ((λc.b) a)
λa.λb.(λc.b) a
λa.λb.b
```
### Comparing the number of steps for different reduction strategies
code:
```rust
use lambda_calculus::*;
use lambda_calculus::data::num::church::fac;
fn main() {
let expr = app(fac(), 3.into_church());
println!("comparing normalizing orders' reduction step count for FAC 3:");
for &order in [NOR, APP, HNO, HAP].iter() {
println!("{}: {}", order, expr.clone().reduce(order, 0));
}
}
```
stdout:
```
comparing normalizing orders' reduction step count for FAC 3:
normal: 46
applicative: 39
hybrid normal: 46
hybrid applicative: 39
```
### Comparing different numeral encodings
code:
```rust
use lambda_calculus::*;
fn main() {
println!("comparing different encodings of number 3 (De Bruijn indices):");
println!(" Church encoding: {:?}", 3.into_church());
println!(" Scott encoding: {:?}", 3.into_scott());
println!(" Parigot encoding: {:?}", 3.into_parigot());
println!("Stump-Fu encoding: {:?}", 3.into_stumpfu());
println!(" binary encoding: {:?}", 3.into_binary());
}
```
stdout:
```
comparing different encodings of number 3 (De Bruijn indices):
Church encoding: λλ2(2(21))
Scott encoding: λλ1(λλ1(λλ1(λλ2)))
Parigot encoding: λλ2(λλ2(λλ2(λλ1)1)(2(λλ1)1))(2(λλ2(λλ1)1)(2(λλ1)1))
Stump-Fu encoding: λλ2(λλ2(2(21)))(λλ2(λλ2(21))(λλ2(λλ21)(λλ1)))
binary encoding: λλλ1(13)
```