rustleaf 0.1.0

A simple programming language interpreter written in Rust
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

use super::{DictRef, ListRef, Range, RustValue, Value};
use anyhow::Result;

#[derive(Debug, Clone)]
pub struct ListIter {
    list: ListRef,
    index: usize,
}

impl ListIter {
    pub fn new(list: ListRef) -> Self {
        Self { list, index: 0 }
    }
}

#[crate::rust_value_any]
impl RustValue for ListIter {
    fn dyn_clone(&self) -> Box<dyn RustValue> {
        Box::new(self.clone())
    }
    fn op_next(&mut self) -> Result<Option<Value>> {
        let list = self.list.borrow();
        if self.index < list.len() {
            let value = list[self.index].clone();
            self.index += 1;
            Ok(Some(value))
        } else {
            Ok(None)
        }
    }
}

#[derive(Debug, Clone)]
pub struct DictIter {
    dict: DictRef,
    keys: Vec<String>,
    index: usize,
}

impl DictIter {
    pub fn new(dict: DictRef) -> Self {
        let keys: Vec<String> = dict.borrow().keys().cloned().collect();
        Self {
            dict,
            keys,
            index: 0,
        }
    }
}

#[crate::rust_value_any]
impl RustValue for DictIter {
    fn dyn_clone(&self) -> Box<dyn RustValue> {
        Box::new(self.clone())
    }
    fn op_next(&mut self) -> Result<Option<Value>> {
        while self.index < self.keys.len() {
            let key = &self.keys[self.index];
            let value = self.dict.borrow().get(key).cloned();
            self.index += 1;

            if value.is_some() {
                return Ok(Some(Value::String(key.clone())));
            }
            // Continue to next key if this one has no value
        }
        Ok(None)
    }
}

#[derive(Debug, Clone)]
pub struct RangeIter {
    current: i64,
    end: i64,
    inclusive: bool,
}

impl RangeIter {
    pub fn new(range: Range) -> Self {
        Self {
            current: range.start,
            end: range.end,
            inclusive: range.inclusive,
        }
    }
}

#[crate::rust_value_any]
impl RustValue for RangeIter {
    fn dyn_clone(&self) -> Box<dyn RustValue> {
        Box::new(self.clone())
    }
    fn op_next(&mut self) -> Result<Option<Value>> {
        let should_continue = if self.inclusive {
            self.current <= self.end
        } else {
            self.current < self.end
        };

        if should_continue {
            let value = Value::Int(self.current);
            self.current += 1;
            Ok(Some(value))
        } else {
            Ok(None)
        }
    }
}