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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use lambda_calculus::*;
use lambda_calculus::data::boolean::fls;
use std::mem;
use self::ListError::*;

#[derive(Debug, PartialEq)]
pub enum ListError {
    NotAList
}

pub fn uncons(term: Term) -> Result<(Term, Term), ListError> {
    if !is_list(&term) {
        Err(NotAList)
    } else {
        let candidate = if let Abs(abstracted) = term { *abstracted } else { term };

        if let Ok((wrapped_a, b)) = candidate.unapp() {
            if wrapped_a.rhs_ref().is_err() {
                Err(NotAList)
            } else {
                Ok((wrapped_a.rhs().unwrap(), b))
            }
        } else {
            Err(NotAList)
        }
    }
}

pub fn uncons_ref(term: &Term) -> Result<(&Term, &Term), ListError> {
    let candidate = if let Abs(ref abstracted) = *term { abstracted } else { term };

    if let Ok((wrapped_a, b)) = candidate.unapp_ref() {
        if wrapped_a.rhs_ref().is_err() {
            Err(NotAList)
        } else {
            Ok((wrapped_a.rhs_ref().unwrap(), b))
        }
    } else {
        Err(NotAList)
    }
}

pub fn uncons_mut(term: &mut Term) -> Result<(&Term, &Term), ListError> {
    let candidate = if let Abs(ref mut abstracted) = *term { abstracted } else { term };

    if let Ok((wrapped_a, b)) = candidate.unapp_mut() {
        if wrapped_a.rhs_ref().is_err() {
            Err(NotAList)
        } else {
            Ok((wrapped_a.rhs_mut().unwrap(), b))
        }
    } else {
        Err(NotAList)
    }
}

pub fn unpair_ref(term: &Term) -> Result<(&Term, &Term), ListError> {
    let candidate = if let Abs(ref abstracted) = *term { abstracted } else { term };

    if let Ok((wrapped_a, b)) = candidate.unapp_ref() {
        if wrapped_a.rhs_ref().is_err() {
            Err(NotAList)
        } else {
            Ok((wrapped_a.rhs_ref().unwrap(), b))
        }
    } else {
        Err(NotAList)
    }
}

pub fn is_pair(term: &Term) -> bool {
    unpair_ref(term).is_ok()
}

pub fn snd_ref(term: &Term) -> Result<&Term, ListError> {
    Ok(unpair_ref(term)?.1)
}

pub fn last_ref(term: &Term) -> Result<&Term, ListError> {
    if !is_pair(term) { return Err(NotAList) }

    let mut last_candidate = snd_ref(term)?;

    while let Ok(second) = snd_ref(last_candidate) {
        last_candidate = second;
    }

    Ok(last_candidate)
}

pub fn is_list(term: &Term) -> bool {
    last_ref(term) == Ok(&fls())
}

pub fn head_ref(term: &Term) -> Result<&Term, ListError> {
    Ok(uncons_ref(term)?.0)
}

pub fn tail(term: Term) -> Result<Term, ListError> {
    Ok(uncons(term)?.1)
}

pub fn push(list: Term, term: Term) -> Result<Term, ListError> {
    if !is_list(&list) && list != fls() { return Err(NotAList) }

    Ok(abs(app!(Var(1), term, list)))
}

pub fn pop(term: &mut Term) -> Result<Term, ListError> {
    let mut to_uncons = mem::replace(term, Var(0)); // replace term with a dummy
    let (head, tail) = uncons_mut(&mut to_uncons)?;
    mem::replace(term, tail.clone()); // replace term with tail

    Ok(head.clone())
}

pub fn listify_terms(terms: Vec<Term>) -> Term {
    let mut ret = fls();

    for term in terms.into_iter().rev() {
        ret = push(ret, term).expect("unwrap 4"); // safe - built from nil()
    }

    ret
}

pub fn vectorize_list(mut list: Term) -> Vec<Term> {
    let mut ret = Vec::new();

    while let Ok(elem) = pop(&mut list) {
        ret.push(elem);
    }

    ret
}