stefans-utils 0.10.1

A collection of useful Rust utility functions, types, and traits.
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

pub trait MapInto<T> {
    fn map_into(self) -> T;
}

impl<A: Into<B>, B> MapInto<Option<B>> for Option<A> {
    fn map_into(self) -> Option<B> {
        self.map(A::into)
    }
}

impl<OkA: Into<OkB>, ErrA: Into<ErrB>, OkB, ErrB> MapInto<Result<OkB, ErrB>> for Result<OkA, ErrA> {
    fn map_into(self) -> Result<OkB, ErrB> {
        match self {
            Ok(a) => Ok(a.into()),
            Err(err_a) => Err(err_a.into()),
        }
    }
}

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

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

    impl From<A> for B {
        fn from(_: A) -> Self {
            B
        }
    }

    impl From<B> for A {
        fn from(_: B) -> Self {
            A
        }
    }

    impl From<C> for D {
        fn from(_: C) -> Self {
            D
        }
    }

    impl From<D> for C {
        fn from(_: D) -> Self {
            C
        }
    }

    #[test]
    fn map_options() {
        fn check<
            A: Into<B> + PartialEq + std::fmt::Debug,
            B: Into<A> + PartialEq + std::fmt::Debug,
        >(
            a: Option<A>,
            b: Option<B>,
        ) {
            assert_eq!(a.map_into(), b);
        }

        check(Option::<A>::Some(A), Option::<B>::Some(B));
        check(Option::<A>::None, Option::<B>::None);
    }

    #[test]
    fn map_results_into() {
        fn check<
            A: Into<B> + PartialEq + std::fmt::Debug,
            B: Into<A> + PartialEq + std::fmt::Debug,
            C: Into<D> + PartialEq + std::fmt::Debug,
            D: Into<C> + PartialEq + std::fmt::Debug,
        >(
            a: Result<A, C>,
            b: Result<B, D>,
        ) {
            assert_eq!(a.map_into(), b);
        }

        // AC/BD - No shared types
        check(Result::<A, C>::Ok(A), Result::<B, D>::Ok(B));
        check(Result::<B, D>::Ok(B), Result::<A, C>::Ok(A));
        check(Result::<A, C>::Err(C), Result::<B, D>::Err(D));
        check(Result::<B, D>::Err(D), Result::<A, C>::Err(C));

        // AC/AD - Shared Ok type
        check(Result::<A, C>::Ok(A), Result::<A, D>::Ok(A));
        check(Result::<A, D>::Ok(A), Result::<A, C>::Ok(A));
        check(Result::<A, C>::Err(C), Result::<A, D>::Err(D));
        check(Result::<A, D>::Err(D), Result::<A, C>::Err(C));

        // AC/BC - Shared Err type
        check(Result::<A, C>::Ok(A), Result::<B, C>::Ok(B));
        check(Result::<B, C>::Ok(B), Result::<A, C>::Ok(A));
        check(Result::<A, C>::Err(C), Result::<B, C>::Err(C));
        check(Result::<B, C>::Err(C), Result::<A, C>::Err(C));

        // AC/AC - All types shared
        check(Result::<A, A>::Ok(A), Result::<A, A>::Ok(A));
        check(Result::<A, A>::Err(A), Result::<A, A>::Err(A));
    }
}