blc 0.7.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

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

#[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"
    );
}