evalit 0.1.1

a toy interpreter
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

use std::fmt;

use crate::{Object, RuntimeError, Value, ValueRef};

use super::OperateKind;

/// ()
impl Object for () {
    fn debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "()")
    }

    fn compare(&self, other: &Value) -> Result<std::cmp::Ordering, RuntimeError> {
        let other = other
            .downcast_ref::<()>()
            .ok_or(RuntimeError::invalid_type::<()>(other))?;
        self.partial_cmp(other).ok_or_else(|| {
            RuntimeError::invalid_operation(
                OperateKind::Compare,
                format!("can not compare () with {other:?}"),
            )
        })
    }
}

impl Object for (ValueRef, ValueRef) {
    fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({:?}, {:?})", self.0, self.1)
    }

    fn index_get(&self, index: &Value) -> Result<ValueRef, RuntimeError> {
        let value = index
            .downcast_ref::<i64>()
            .ok_or(RuntimeError::invalid_type::<i64>(index))?;

        match *value {
            0 => Ok(self.0.clone()),
            1 => Ok(self.1.clone()),
            _ => Err(RuntimeError::IndexOutOfBounds {
                index: *value,
                length: 2,
            }),
        }
    }
}

// impl Object for (ValueRef, ValueRef) {
//     fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
//         write!(f, "({:?}, {:?})", self.0, self.1)
//     }

//     fn index_get(&self, index: &Value) -> Result<ValueRef, RuntimeError> {
//         let value = index
//             .downcast_ref::<i64>()
//             .ok_or(RuntimeError::invalid_type::<i64>(index))?;

//         match *value {
//             0 => Ok(self.0.clone()),
//             1 => Ok(self.1.clone()),
//             _ => Err(RuntimeError::IndexOutOfBounds {
//                 index: *value,
//                 length: 2,
//             }),
//         }
//     }
// }

// impl<T: Object + Clone> Object for (T, Value) {
//     fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
//         write!(f, "({:?}, {:?})", self.0, self.1)
//     }

//     fn index_get(&self, index: &Value) -> Result<Value, RuntimeError> {
//         let value = index
//             .downcast_ref::<i64>()
//             .ok_or(RuntimeError::invalid_type::<i64>(index))?;

//         match *value {
//             0 => Ok(Value::new(self.0.clone())),
//             1 => Ok(self.1.clone()),
//             _ => Err(RuntimeError::IndexOutOfBounds {
//                 index: *value,
//                 length: 2,
//             }),
//         }
//     }
// }

// impl Object for (usize, Value) {
//     fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
//         write!(f, "({}, {})", self.0, self.1)
//     }

//     fn index_get(&self, index: &Value) -> Result<Value, RuntimeError> {
//         let value = index
//             .downcast_ref::<i64>()
//             .ok_or(RuntimeError::invalid_type::<i64>(index))?;

//         match *value {
//             0 => Ok(Value::new(self.0.clone())),
//             1 => Ok(self.1.clone()),
//             _ => Err(RuntimeError::IndexOutOfBounds {
//                 index: *value,
//                 length: 2,
//             }),
//         }
//     }
// }

impl<T1, T2> Object for (T1, T2)
where
    T1: Object + Clone,
    T2: Object + Clone,
{
    fn debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "()")
    }

    fn index_get(&self, index: &Value) -> Result<ValueRef, RuntimeError> {
        let value = index
            .downcast_ref::<i64>()
            .ok_or(RuntimeError::invalid_type::<i64>(index))?;

        match *value {
            0 => Ok(ValueRef::new(self.0.clone())),
            1 => Ok(ValueRef::new(self.1.clone())),
            _ => Err(RuntimeError::IndexOutOfBounds {
                index: *value,
                length: 2,
            }),
        }
    }
}