https://github.com/ljedrz/blc

Binary lambda calculus
https://github.com/ljedrz/blc

binaryformat encoding lambda-calculus rust-library

Last synced: about 1 month ago
JSON representation

Binary lambda calculus

• Host: GitHub
• URL: https://github.com/ljedrz/blc
• Owner: ljedrz
• License: cc0-1.0
• Created: 2017-04-07T11:48:33.000Z (about 7 years ago)
• Default Branch: master
• Last Pushed: 2018-01-29T14:13:40.000Z (over 6 years ago)
• Last Synced: 2024-05-10T17:43:01.560Z (about 2 months ago)
• Topics: binaryformat, encoding, lambda-calculus, rust-library
• Language: Rust
• Size: 63.5 KB
• Stars: 7
• Watchers: 4
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Lists

• awesome-rust-formalized-reasoning - blc - implementation of the binary lambda calculus. (Lambda Calculus / Libraries)

README

        
# blc

**blc** is an implementation of the

[binary lambda calculus](https://esolangs.org/wiki/Binary_lambda_calculus).

## Binary lambda calculus basics

Binary lambda calculus (BLC) is a minimal, purely functional programming language based on a binary

encoding of the untyped [lambda calculus](https://en.wikipedia.org/wiki/Lambda_calculus) with

[De Bruijn indices](https://en.wikipedia.org/wiki/De_Bruijn_index).

Lambda terms have the following representation in BLC:

| term        | lambda | BLC            |

--------------|--------|----------------|

| abstraction | λM     | 00M            |

| application | MN     | 01MN           |

| variable    | i      | 1i0 |

Since BLC programs are basically lambda calculus terms, they can be applied to other terms. In

order for them to be applicable to binary (but not BLC-encoded) input, it has to be lambda-encoded

first. Bytestrings are lambda-encoded as

[single-pair lists](https://en.wikipedia.org/wiki/Church_encoding#One_pair_as_a_list_node) of bytes

and bytes are lambda-encoded as single-pair lists of lambda-encoded bits.

Bits 0 and 1 are lambda-encoded as

[Church booleans](https://en.wikipedia.org/wiki/Church_encoding#Church_Booleans):

| bit | lambda      | BLC     |

|-----|-------------|---------|

|  0  | λλ2 (true)  | 0000110 |

|  1  | λλ1 (false) | 000010  |

Example: BLC-encoding steps for a byte representing the ASCII/UTF-8 encoded letter 'a':

| encoding  | representation |

|-----------|----------------|

| decimal   | 96             |

| binary    | 01100001       |

| lambda    | λ1(λλ2)(λ1(λλ1)(λ1(λλ1)(λ1(λλ2)(λ1(λλ2)(λ1(λλ2)(λ1(λλ2)(λ1(λλ1)(λλ1)))))))) |

| BLC (hex) | 16 16 0c 2c 10 b0 42 c1 85 83 0b 06 16 0c 2c 10 41 00 |

## [Documentation](https://docs.rs/blc)

## Example BLC program

```

extern crate blc;

extern crate lambda_calculus;

use blc::*;

use blc::encoding::binary::to_bits;

use blc::execution::Input;

use lambda_calculus::{parse, DeBruijn};

fn repeat(input: &[u8]) -> String {

    let code_lambda = "λ1((λ11)(λλλλλ14(3(55)2)))1"; // the program (a lambda expression)

    let code_term   = parse(code_lambda, DeBruijn).unwrap();

    let code_blc    = to_bits(&code_term); // the program in binary lambda calculus

    run(&*code_blc, Input::Bytes(input)).unwrap()

}

fn main() {

    assert_eq!(

        repeat(&*b"hurr"),

        "hurrhurr"

    );

}

```