gorf-lcobj 0.1.1

Lambda calulcus backend library
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
62
63
64
65
66
67
68
69
70
71
72

use std::{collections::BTreeMap, convert::Infallible};

use gorf_core::{brujin, debrijun, Id};
use gorf_kiselyov::{RealSki, Ski};

use crate::{Obj, Symbol};

pub fn bake_ski(a: &Ski, x: &mut Obj<Id, Infallible>) -> Id {
    let i: Id = format!("__{a:?}").into();
    if x.syms.contains_key(&i) {
        return i;
    };
    let s = match a {
        Ski::S => Symbol {
            r#impl: debrijun(lambda_calculus::combinators::S()),
            deps: vec![],
        },
        Ski::K => Symbol {
            r#impl: debrijun(lambda_calculus::combinators::K()),
            deps: vec![],
        },
        Ski::B => Symbol {
            r#impl: debrijun(lambda_calculus::combinators::B()),
            deps: vec![],
        },
        Ski::R => Symbol {
            r#impl: debrijun(lambda_calculus::combinators::R()),
            deps: vec![],
        },
        Ski::U => Symbol {
            deps: vec![],
            r#impl: debrijun(lambda_calculus::app(
                lambda_calculus::app(
                    lambda_calculus::combinators::S(),
                    lambda_calculus::combinators::I(),
                ),
                lambda_calculus::combinators::I(),
            )),
        },
        Ski::I => Symbol {
            r#impl: debrijun(lambda_calculus::combinators::I()),
            deps: vec![],
        },
        Ski::App(ski, ski1) => Symbol {
            deps: vec![bake_ski(ski.as_ref(), &mut *x), bake_ski(ski1.as_ref(), x)],
            r#impl: debrijun(lambda_calculus::combinators::I()),
        },
    };
    x.syms.insert(i.clone(), s);
    return i;
}
pub fn bake(a: &Symbol<Id, Infallible>, p: &str, x: &mut Obj<Id, Infallible>) {
    let s = bake_ski(&Ski::convert_default(brujin(a.r#impl.clone())), x);
    x.syms.insert(
        Id(format!("{p}")),
        Symbol {
            deps: [s].into_iter().chain(a.deps.iter().cloned()).collect(),
            r#impl: debrijun(lambda_calculus::combinators::I()),
        },
    );
}
pub fn cache(a: &Obj<Id, Infallible>) -> Obj<Id, Infallible> {
    return a.syms.iter().fold(
        Obj {
            syms: BTreeMap::new(),
        },
        |mut x, (si, s)| {
            bake(s, &si.0, &mut x);
            return x;
        },
    );
}