typed-eval 0.1.0

A type-safe expression evaluation engine.
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

use crate::{Error, EvalType, Result, TypeInfo};
use std::{any::Any, ops::Deref};

// the function with a dynamically known type
pub struct DynFn {
    pub arg_type: TypeInfo,
    pub ret_type: TypeInfo,
    boxed_fun: Box<dyn ClonableAny>,
}

impl DynFn {
    pub fn new<Arg, Ret>(
        f: impl for<'a> Fn(&'a Arg) -> Ret::RefType<'a> + Clone + 'static,
    ) -> Self
    where
        Arg: EvalType,
        Ret: EvalType,
    {
        Self {
            boxed_fun: Box::new(BoxedFn(Box::new(f))),
            arg_type: Arg::type_info(),
            ret_type: Ret::type_info(),
        }
    }

    pub fn downcast<Arg, Ret>(&self) -> Result<BoxedFn<Arg, Ret>>
    where
        Arg: EvalType,
        Ret: EvalType,
    {
        Ok(self.boxed_fun.as_any().downcast_ref().cloned().ok_or_else(
            || Error::InternalDynFnDowncastError {
                expected_arg: Arg::type_info(),
                expected_ret: Ret::type_info(),
                got_arg: self.arg_type,
                got_ret: self.ret_type,
            },
        )?)
    }
}

impl Clone for DynFn {
    fn clone(&self) -> Self {
        DynFn {
            boxed_fun: self.boxed_fun.clone_box(),
            ..*self
        }
    }
}

// the function with a statically known type
pub struct BoxedFn<Arg, Ret>(Box<dyn ClonableFn<Arg, Ret>>)
where
    Ret: EvalType;

impl<Arg, Ret> Clone for BoxedFn<Arg, Ret>
where
    Ret: EvalType,
{
    fn clone(&self) -> Self {
        self.clone_boxed()
    }
}

// implementing Deref allows to use the call syntax on the BoxedFn instances
impl<Arg, Ret> Deref for BoxedFn<Arg, Ret>
where
    Ret: EvalType,
{
    type Target = Box<dyn ClonableFn<Arg, Ret>>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

trait ClonableAny: Any {
    fn clone_box(&self) -> Box<dyn ClonableAny>;
    fn as_any(&self) -> &dyn Any;
}

impl<T: Any + Clone> ClonableAny for T {
    fn clone_box(&self) -> Box<dyn ClonableAny> {
        Box::new(self.clone())
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
}

pub trait ClonableFn<Arg, Ret>:
    for<'a> Fn(&'a Arg) -> Ret::RefType<'a>
where
    Ret: EvalType,
{
    fn clone_boxed(&self) -> BoxedFn<Arg, Ret>;
}

// implement ClonableFn for every matching function
impl<Arg, Ret, F> ClonableFn<Arg, Ret> for F
where
    Ret: EvalType,
    F: for<'a> Fn(&'a Arg) -> Ret::RefType<'a> + Clone + 'static,
{
    fn clone_boxed(&self) -> BoxedFn<Arg, Ret> {
        BoxedFn(Box::new(self.clone()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dyn_fn() {
        // here we construct a function that takes an (i64,i64) tuple and returns the first part
        // but the type of the variable just DynFn, no mention of tuples and i64
        let dyn_fn = DynFn::new::<_, i64>(|a: &(i64, i64)| a.0);

        // here we get back to the callable function with known types
        // but for that we need to know exact types at compile time
        let concrete_fn = dyn_fn.downcast::<(i64, i64), i64>().unwrap();

        // and here we call the downcasted function to test if it really works as intended
        assert_eq!((concrete_fn)(&(10, 20)), 10);
    }
}