rue-lir 0.10.0

Provides a low-level intermediate representation that compiles to CLVM.
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

use id_arena::Arena;

use crate::{Lir, LirId, optimize::optimize};

pub fn opt_truthy(arena: &mut Arena<Lir>, value: LirId) -> Result<bool, LirId> {
    match arena[value].clone() {
        Lir::Atom(atom) => Ok(!atom.is_empty()),
        Lir::Cons(..) => Ok(true),
        Lir::Listp(inner, atom_can_be_truthy) => {
            if atom_can_be_truthy {
                Err(value)
            } else {
                opt_truthy(arena, inner)
            }
        }
        Lir::Not(inner) => {
            if let Lir::Eq(left, right) = arena[inner].clone() {
                if let Lir::Atom(left) = arena[left].clone()
                    && left.is_empty()
                {
                    return Err(right);
                }

                if let Lir::Atom(right) = arena[right].clone()
                    && right.is_empty()
                {
                    return Err(left);
                }
            }

            Err(value)
        }
        Lir::Eq(left, right) => {
            if let Lir::Atom(left) = arena[left].clone()
                && left.is_empty()
            {
                let not = arena.alloc(Lir::Not(right));
                let not = optimize(arena, not);
                return opt_truthy(arena, not);
            }

            if let Lir::Atom(right) = arena[right].clone()
                && right.is_empty()
            {
                let not = arena.alloc(Lir::Not(left));
                let not = optimize(arena, not);
                return opt_truthy(arena, not);
            }

            Err(value)
        }
        _ => Err(value),
    }
}