reflected 0.30.0

Something like reflection
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

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum OptionalType {
    Float,
    Integer,
    Text,
    Date,
    Decimal,
    Bool,
    Duration,
    DateTime,
}

impl OptionalType {
    pub const fn from_type(tp: &Type) -> Self {
        match tp {
            Type::Float => OptionalType::Float,
            Type::Integer => OptionalType::Integer,
            Type::Text => OptionalType::Text,
            Type::Date => OptionalType::Date,
            Type::Decimal => OptionalType::Decimal,
            Type::Bool => OptionalType::Bool,
            Type::Duration => OptionalType::Duration,
            Type::DateTime => OptionalType::DateTime,
            Type::Optional(_) | Type::Enum => unreachable!(),
        }
    }

    pub const fn to_non_optional(&self) -> Type {
        match self {
            OptionalType::Float => Type::Float,
            OptionalType::Integer => Type::Integer,
            OptionalType::Text => Type::Text,
            OptionalType::Date => Type::Date,
            OptionalType::Decimal => Type::Decimal,
            OptionalType::Bool => Type::Bool,
            OptionalType::Duration => Type::Duration,
            OptionalType::DateTime => Type::DateTime,
        }
    }
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Type {
    Float,
    Integer,
    Text,
    Date,
    Decimal,
    Bool,
    Enum,
    Duration,
    DateTime,
    Optional(OptionalType),
}

impl Type {
    pub const fn to_optional(self) -> Self {
        Self::Optional(OptionalType::from_type(&self))
    }

    pub fn is_type(&self, tp: Self) -> bool {
        if self == &tp {
            return true;
        }

        if let Self::Optional(opt) = self
            && tp == opt.to_non_optional()
        {
            return true;
        }

        false
    }

    pub fn is_float(&self) -> bool {
        self.is_type(Self::Float)
    }

    pub fn is_integer(&self) -> bool {
        self.is_type(Self::Integer)
    }

    pub fn is_text(&self) -> bool {
        self.is_type(Self::Text)
    }

    pub fn is_date(&self) -> bool {
        self.is_type(Self::Date)
    }

    pub fn is_decimal(&self) -> bool {
        self.is_type(Self::Decimal)
    }

    pub fn is_bool(&self) -> bool {
        self.is_type(Self::Bool)
    }

    pub fn is_enum(&self) -> bool {
        self.is_type(Self::Enum)
    }

    pub fn is_duration(&self) -> bool {
        self.is_type(Self::Duration)
    }

    pub fn is_optional(&self) -> bool {
        matches!(self, Self::Optional(_))
    }

    pub fn get_optional(&self) -> Option<OptionalType> {
        match self {
            Self::Optional(op) => Some(*op),
            _ => None,
        }
    }

    pub fn is_number(&self) -> bool {
        self.is_integer() || self.is_float()
    }
}

#[cfg(test)]
mod test {
    use crate::Type;

    #[test]
    fn test() {
        assert!(Type::Float.is_float());
        assert!(Type::Float.to_optional().is_float());
    }
}