enumorph 0.1.3

Derive macro to generate `TryFrom` and `From` implementations for converting between newtype enum variants and their wrapped values
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

#![no_std]

pub use enumorph_derive::Enumorph;

/// Convenience trait around the conversions provided by [`Enumorph`], but with
/// the generics on the functions instead of the trait.
///
/// ```rust
/// use enumorph::{Enumorph, EnumorphAs};
///
/// #[derive(Enumorph)]
/// enum Enum1 {
///     A(A),
///     B(B),
/// }
///
/// #[derive(Enumorph)]
/// enum Enum2 {
///     A(A),
///     C(C),
/// }
///
/// struct A;
/// struct B;
/// struct C;
///
/// let enum_1 = A.widen::<Enum1>();
/// let enum_2 = A.widen::<Enum2>();
/// ```
pub trait EnumorphAs: Sized {
    fn widen<T>(self) -> T
    where
        Self: Into<T>,
    {
        self.into()
    }

    fn narrow<T>(self) -> Result<T, Self>
    where
        Self: TryInto<T, Error = Self>,
    {
        self.try_into()
    }
}

impl<T> EnumorphAs for T {}

pub trait Enumorph<T>: TryFrom<T, Error = T> + Into<T> {}
impl<T, U> Enumorph<U> for T where T: TryFrom<U, Error = U> + Into<U> {}

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

    #[test]
    fn enumorph_as() {
        #[derive(Debug, PartialEq, Enumorph)]
        enum Enum<T, U> {
            A(A<T>),
            B(B<U>),
        }

        #[derive(Debug, PartialEq)]
        struct A<T>(T);

        #[derive(Debug, PartialEq)]
        struct B<U>(U);

        assert_eq!(A("a").widen::<Enum<&str, u8>>(), Enum::A(A("a")));
        assert_eq!(Enum::<&str, u8>::A(A("a")).narrow::<A<_>>(), Ok(A("a")));

        assert_eq!(B(1).widen::<Enum<&str, u8>>(), Enum::B(B(1)));
        assert_eq!(Enum::<&str, u8>::B(B(1)).narrow::<B<_>>(), Ok(B(1)));
    }

    #[test]
    fn try_from_into() {
        #[derive(Debug, PartialEq, Enumorph)]
        enum A {
            B(B),
            C(C),
            D(D),
        }

        #[derive(Debug, PartialEq)]
        struct B;
        #[derive(Debug, PartialEq)]
        struct C;

        #[derive(Debug, PartialEq, Enumorph)]
        enum D {
            E(E),
        }

        #[derive(Debug, PartialEq)]
        struct E;

        assert!(matches!(A::B(B).try_into(), Ok(B)));
        assert!(matches!(A::C(C).try_into(), Ok(C)));
        assert!(matches!(A::D(D::E(E)).try_into(), Ok(D::E(E))));
        // currently doesn't work
        // assert_eq!(A::D(D::E(E)).try_into(), Ok(E));

        assert!(matches!(B.into(), A::B(B)));
        assert!(matches!(C.into(), A::C(C)));
        assert!(matches!(D::E(E).into(), A::D(D::E(E))));
        // currently doesn't work
        // assert!(matches!(E.into(), A::D(D::E(E))));
    }

    #[test]
    fn ui() {
        let t = trybuild::TestCases::new();
        t.pass("tests/ui/pass/*.rs");
        t.compile_fail("tests/ui/compile_fail/*.rs");
    }
}