constraint 0.1.0

Easly create types with the guarantees you need
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

#[doc = include_str!("../README.md")]

/// Declares a new constrained type.
///
/// # Examples
///
/// A bounded `i32` type:
/// ```
/// use std::convert::TryFrom;
/// constraint::constraint!{
///     /// Some documentation, must be inside the macro
///     // You can also add any meta attributes
///     #[derive(Default)]
///     pub BoundedI32(i32) if |x: &i32| *x > 2 && *x < 5
/// }
///
/// assert!(BoundedI32::try_from(2).is_err());
/// assert!(BoundedI32::try_from(4).is_ok());
/// ```
#[macro_export]
macro_rules! constraint {
    (
        $(#[$outer:meta])*
        $vis:vis $name:ident($typ:ident) if $cond:expr
    ) => {
        $(#[$outer])*
        $vis struct $name($typ);

        impl $name {
            #[allow(dead_code)]
            pub fn get(&self) -> &$typ {
                &self.0
            }

            #[allow(dead_code)]
            pub fn get_mut(&mut self) ->&mut $typ {
                &mut self.0
            }

            #[allow(dead_code)]
            pub fn into_inner(self) -> $typ {
                self.0
            }
        }

        impl std::convert::TryFrom<$typ> for $name {
            type Error = ();

            fn try_from(value: $typ) -> Result<Self, Self::Error> {
                if $cond(&value) {
                    Ok(Self(value))
                }
                else {
                    Err(())
                }
            }
        }
    };
}

#[cfg(test)]
mod tests {
    use std::convert::TryFrom;

    #[test]
    fn compile_bounded_i32() {
        crate::constraint! { pub(crate) Bounded(i32) if |value: &i32| *value < 5 && *value > 2 }

        assert!(Bounded::try_from(2).is_err());
        assert!(Bounded::try_from(3).is_ok());
        assert!(Bounded::try_from(4).is_ok());
        assert!(Bounded::try_from(5).is_err());
    }
}