scriptful 0.2.1

A minimalist, `no_std` stack machine library for interpreting domain specific interpreted languages.
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

use crate::core::value::Value;

/// An `Item` is each one of the entities that conform a [`Script`][Script].
///
/// In other words, a [`Script`][Script] is no more than an array of `Item`s in the likes of
/// `[Item<Op, Val>]`.
///
/// `Ìtem` does not implement any methods other than implementations of some traits from the
/// [`core`][core] crate.
///
/// [Script]: ../type.Script.html
/// [core]: https://doc.rust-lang.org/nightly/core/
#[derive(Debug)]
pub enum Item<Op, Val = Value>
where
    Op: core::fmt::Debug + core::cmp::Eq,
    Val: core::fmt::Debug + core::cmp::PartialEq,
{
    /// An operator code, either a variant of an user-defined [`enum`][enum] containing different
    /// operator identifiers, or any of the ones found in the [`op_systems`][op_systems] module.
    ///
    /// [enum]: https://doc.rust-lang.org/std/keyword.enum.html
    /// [op_systems]: ../../op_systems/
    Operator(Op),
    /// A value, either a variant of an user-defined [`enum`][enum] representing a type system, or
    /// an instance of any of the variants of [`Value`][Value], i.e. [`Boolean`][Boolean],
    /// [`Float`][Float], [`Integer`][Integer] or [`String`][String].
    ///
    /// [enum]: https://doc.rust-lang.org/std/keyword.enum.html
    /// [Value]: ../value/enum.Value.html
    /// [Boolean]: ../value/enum.Value.html#variant.Boolean
    /// [Float]: ../value/enum.Value.html#variant.Float
    /// [Integer]: ../value/enum.Value.html#variant.Integer
    /// [String]: ../value/enum.Value.html#variant.String
    Value(Val),
}

impl<Op, Val> PartialEq for Item<Op, Val>
where
    Op: core::fmt::Debug + core::cmp::Eq,
    Val: core::fmt::Debug + core::cmp::PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Operator(op), Self::Operator(other_op)) => op == other_op,
            (Self::Value(value), Self::Value(other_value)) => value == other_value,
            _ => false,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::core::item::Item::{self, *};
    use crate::core::value::Value::*;

    #[test]
    fn test_eq() {
        let op_item1: Item<u8> = Operator(u8::default());
        let op_item2: Item<u8> = Operator(u8::default());

        assert_eq!(op_item1, op_item2);

        let val_item1: Item<u8> = Value(Integer(i128::default()));
        let val_item2: Item<u8> = Value(Integer(i128::default()));

        assert_eq!(val_item1, val_item2);
    }

    #[test]
    fn test_ne() {
        let op_item1: Item<u8> = Operator(u8::default());
        let op_item2: Item<u8> = Operator(u8::default() + 1);

        assert_ne!(op_item1, op_item2);

        let val_item1: Item<u8> = Value(Integer(i128::default()));
        let val_item2: Item<u8> = Value(Integer(i128::default() + 1));

        assert_ne!(val_item1, val_item2);

        assert_ne!(op_item1, val_item1);
        assert_ne!(op_item1, val_item2);
        assert_ne!(op_item2, val_item1);
        assert_ne!(op_item2, val_item2);
    }
}