v_eval 0.6.0

Expression evaluator with context
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

use std::{convert::TryInto, str::FromStr};

use crate::{reflect::Eval, Value};

macro_rules! pop {
    ($stack:ident) => {
        $stack.pop().ok_or(()).and_then(TryInto::try_into)?
    };
}

macro_rules! fun_arg {
    ($m:ident, $t1:ty, $t2:ty, $stack:ident) => {{
        let op2: $t1 = pop!($stack);
        let op1: $t2 = pop!($stack);
        op1.$m(op2).into()
    }};
}

macro_rules! fun_arg_s {
    ($m:ident, $t:ty, $stack:ident) => {
        fun_arg!($m, $t, $t, $stack)
    };
}

macro_rules! fun {
    ($m:ident, $t:ty, $stack:ident) => {{
        let op1: $t = pop!($stack);
        op1.$m().into()
    }};
}

macro_rules! fun_un {
    ($m:ident, $cb: ident, $stack:ident) => {{
        let op1 = $cb!($stack.pop().ok_or(())?);
        op1.$m().into()
    }};
}

macro_rules! fun_arg_un {
    ($m:ident, $cb: ident, $stack:ident) => {{
        let op2 = $cb!($stack.pop().ok_or(())?);
        let op1 = $cb!($stack.pop().ok_or(())?);
        op1.$m(op2).into()
    }};
}

pub mod dyn_type;
pub mod f64_t;
pub mod option_t;
pub mod slice_t;
pub mod str_t;
pub mod vec_t;

pub(crate) trait HasArg: Copy {
    fn has_arg(self) -> bool;
}

#[derive(Clone, Copy, Debug)]
pub(crate) enum Method {
    DynType(dyn_type::Fun),
    F64(f64_t::Fun),
    Option(option_t::Fun),
    Slice(slice_t::Fun),
    Str(str_t::Fun),
    VecT(vec_t::Fun),
}

use Method::*;

impl FromStr for Method {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        macro_rules! parse {
            ($p:path) => {
                match s.parse().map($p) {
                    Ok(m) => m,
                    Err(_) => return Err(()),
                }
            };
            ($p:path, $($t:tt)+) => {
                match s.parse().map($p) {
                    Ok(m) => m,
                    Err(_) => parse!($($t)+)
                }
            };
        }
        Ok(parse!(DynType, Option, VecT, Slice, Str, F64))
    }
}

impl Eval for Method {
    fn eval(self, stack: &mut Vec<Value>) -> Result<(), ()> {
        match self {
            DynType(f) => f.eval(stack),
            F64(f) => f.eval(stack),
            Option(f) => f.eval(stack),
            Slice(f) => f.eval(stack),
            Str(f) => f.eval(stack),
            VecT(f) => f.eval(stack),
        }
    }
}

impl HasArg for Method {
    fn has_arg(self) -> bool {
        match self {
            DynType(f) => f.has_arg(),
            F64(f) => f.has_arg(),
            Option(f) => f.has_arg(),
            Slice(f) => f.has_arg(),
            Str(f) => f.has_arg(),
            VecT(f) => f.has_arg(),
        }
    }
}