blc 0.6.0

An implementation of the binary lambda calculus.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

extern crate blc;
extern crate lambda_calculus;

use blc::*;
use blc::encoding::lambda::encode;
use blc::execution::Input;
use lambda_calculus::*;
use lambda_calculus::data::num::church::{is_zero, rem};

#[test]
fn fizz_buzz() {
    let fizzbuzz_single =
        abs(
            app!(
                is_zero(),
                app!(rem(), Var(1), 15.into_church()),
                encode(&*b"FizzBuzz"),
                app!(
                    is_zero(),
                    app!(rem(), Var(1), 3.into_church()),
                    encode(&*b"Fizz"),
                    app!(
                        is_zero(),
                        app!(rem(), Var(1), 5.into_church()),
                        encode(&*b"Buzz"),
                        Var(1)
                    )
                )
            )
        );
    let fizzbuzz_blc = to_bits(&fizzbuzz_single);

    assert_eq!(
        run(&*fizzbuzz_blc, Input::Bits(&to_bits(&1.into_church()))).unwrap(),
        "(λλ21)" // Church-encoded 1
    );

    assert_eq!(
        run(&*fizzbuzz_blc, Input::Bits(&to_bits(&2.into_church()))).unwrap(),
        "(λλ2(21))" // Church-encoded 2
    );
    assert_eq!(
        run(&*fizzbuzz_blc, Input::Bits(&to_bits(&3.into_church()))).unwrap(),
        "Fizz"
    );

    assert_eq!(
        run(&*fizzbuzz_blc, Input::Bits(&to_bits(&4.into_church()))).unwrap(),
        "(λλ2(2(2(21))))" // Church-encoded 4
    );

    assert_eq!(
        run(&*fizzbuzz_blc, Input::Bits(&to_bits(&5.into_church()))).unwrap(),
        "Buzz"
    );

    assert_eq!(
        run(&*fizzbuzz_blc, Input::Bits(&to_bits(&15.into_church()))).unwrap(),
        "FizzBuzz"
    );
}