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

use crate::Error;
use std::ops::Deref;

pub type Result<T> = std::result::Result<T, Errors>;

#[derive(Debug, PartialEq)]
pub struct Errors(Vec<Error>);

impl Deref for Errors {
    type Target = [Error];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl From<Error> for Errors {
    fn from(value: Error) -> Self {
        Self(vec![value])
    }
}

impl From<Vec<Error>> for Errors {
    fn from(value: Vec<Error>) -> Self {
        Self(value)
    }
}

impl Errors {
    pub fn empty() -> Errors {
        Self(vec![])
    }

    pub fn combine(
        a: impl Into<Option<Errors>>,
        b: impl Into<Option<Errors>>,
    ) -> Option<Errors> {
        match (a.into(), b.into()) {
            (None, None) => None,
            (Some(e), None) | (None, Some(e)) => Some(e),
            (Some(mut e1), Some(e2)) => {
                e1.0.extend(e2.0);
                Some(e1)
            }
        }
    }

    pub fn append(&mut self, errors: impl Into<Errors>) {
        self.0.append(&mut errors.into().0);
    }
}

/// This trait is implemented for tuples and vectors, so it is possible to check multiple results,
/// and collect all errors before bailing out.
/// This will return errors from both compute_a and compute_b, if any:
/// `let (a, b) = (compute_a(), compute_b()).all_ok()?`
pub trait CombineResults {
    type Output;
    fn all_ok(self) -> Result<Self::Output>;
}

impl<T, E> CombineResults for Vec<std::result::Result<T, E>>
where
    E: Into<Errors>,
{
    type Output = Vec<T>;

    fn all_ok(self) -> Result<Self::Output> {
        let mut values = Vec::with_capacity(self.len());
        let mut errors: Option<Errors> = None;

        for res in self {
            match res {
                Ok(v) => values.push(v),
                Err(e) => {
                    errors = Errors::combine(errors, e.into());
                }
            }
        }

        if let Some(e) = errors {
            Err(e)
        } else {
            Ok(values)
        }
    }
}

macro_rules! impl_combine_results {
    ( $( $name:ident, $err:ident ),+ ) => {
        impl< $( $name, $err ),+ > CombineResults for ( $( std::result::Result<$name, $err> ),+ )
        where $( $err: Into<Errors>, )+
        {
            type Output = ( $( $name ),+ );

            #[allow(non_snake_case)]
            fn all_ok(self) -> Result<Self::Output> {
                let ( $( $name ),+ ) = self;

                let mut errors: Option<Errors> = None;

                $(
                    let $name = match $name {
                        Ok(v) => Some(v),
                        Err(e) => {
                            errors = Errors::combine(errors, e.into());
                            None
                        }
                    };
                )+

                if let Some(e) = errors {
                    Err(e)
                } else {
                    Ok(( $( $name.unwrap() ),+ ))
                }
            }
        }
    };
}
impl_combine_results!(A, EA, B, EB);
impl_combine_results!(A, EA, B, EB, C, EC);
impl_combine_results!(A, EA, B, EB, C, EC, D, ED);
impl_combine_results!(A, EA, B, EB, C, EC, D, ED, E, EE);
impl_combine_results!(A, EA, B, EB, C, EC, D, ED, E, EE, F, EF);