klvmr 0.2.5

Implementation of `klvm` for Chik Network's cryptocurrency
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

use super::allocator::{Allocator, NodePtr, SExp};
use std::fmt;

pub struct Node<'a> {
    pub allocator: &'a Allocator,
    pub node: NodePtr,
}

impl<'a> Node<'a> {
    pub fn new(allocator: &'a Allocator, node: NodePtr) -> Self {
        Node { allocator, node }
    }

    pub fn with_node(&self, node: NodePtr) -> Self {
        Node::new(self.allocator, node)
    }

    pub fn sexp(&self) -> SExp {
        self.allocator.sexp(self.node)
    }

    pub fn atom(&self) -> Option<&'a [u8]> {
        match self.sexp() {
            SExp::Atom(_) => Some(self.allocator.atom(self.node)),
            _ => None,
        }
    }

    pub fn pair(&self) -> Option<(Node<'a>, Node<'a>)> {
        match self.sexp() {
            SExp::Pair(left, right) => Some((self.with_node(left), self.with_node(right))),
            _ => None,
        }
    }

    pub fn nullp(&self) -> bool {
        match self.sexp() {
            SExp::Atom(a) => a.is_empty(),
            _ => false,
        }
    }

    pub fn arg_count_is(&self, mut count: usize) -> bool {
        let mut ptr: Self = self.clone();
        loop {
            if count == 0 {
                return ptr.nullp();
            }
            match ptr.sexp() {
                SExp::Pair(_, new_ptr) => {
                    ptr = ptr.with_node(new_ptr).clone();
                }
                _ => return false,
            }
            count -= 1;
        }
    }

    pub fn null(&self) -> Self {
        self.with_node(self.allocator.null())
    }

    pub fn one(&self) -> Self {
        self.with_node(self.allocator.one())
    }

    pub fn as_bool(&self) -> bool {
        match self.atom() {
            Some(v0) => !v0.is_empty(),
            _ => true,
        }
    }

    pub fn from_bool(&self, b: bool) -> Self {
        if b {
            self.one()
        } else {
            self.null()
        }
    }
}

impl<'a> fmt::Debug for Node<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.sexp() {
            SExp::Pair(l, r) => f
                .debug_tuple("")
                .field(&self.with_node(l))
                .field(&self.with_node(r))
                .finish(),
            SExp::Atom(a) => self.allocator.buf(&a).fmt(f),
        }
    }
}

impl<'a> Clone for Node<'a> {
    fn clone(&self) -> Self {
        self.with_node(self.node)
    }
}

impl<'a> IntoIterator for &Node<'a> {
    type Item = Node<'a>;
    type IntoIter = Node<'a>;

    fn into_iter(self) -> Self::IntoIter {
        self.clone()
    }
}

impl<'a> Iterator for Node<'a> {
    type Item = Node<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.pair() {
            Some((first, rest)) => {
                self.node = rest.node;
                Some(first)
            }
            _ => None,
        }
    }
}