uncollate 0.2.1

Uncollate array of structs into arrays of field
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

pub use uncollate_macro::Uncollate;
pub trait Uncollate<T> {
    fn uncollate(self) -> T;
}

pub trait Collated<T: Uncollated> {
    fn uncollate_one(self, uncollated: &mut T);
}

pub trait Uncollated: Default {}

impl<U: Uncollated, C: Collated<U>, T: IntoIterator<Item = C>> Uncollate<U> for T {
    fn uncollate(self) -> U {
        let mut uncollated: U = Default::default();
        for collated in self {
            collated.uncollate_one(&mut uncollated);
        }
        uncollated
    }
}

/// uncollates by reference
/// 
/// ```
/// use uncollate::uncollate;
/// 
/// struct Greet {
///     greeting: String,
///     who: String,
/// }
/// 
/// let greetings = vec![
///     Greet { greeting: "Hello".into(), who: "world!".into() },
///     Greet { greeting: "Howdy".into(), who: "partner".into() }
/// ];
/// 
/// let whos = uncollate!(&greetings.who);
/// assert_eq!(whos, vec![&greetings[0].who, &greetings[1].who])
/// ```
#[macro_export]
macro_rules! uncollate {
    (&$vec:ident.$field:ident) => {
        (&$vec).into_iter().map(|elem| &elem.$field).collect::<::std::vec::Vec<_>>()
    };
    (&$vec:ident.$field:ident, $t:ty) => {
        (&$vec).into_iter().map(|elem| &elem.$field).collect::<$t>()
    };
    (&mut $vec:ident.$field:ident) => {
        (&mut $vec).into_iter().map(|elem| &mut elem.$field).collect::<::std::vec::Vec<_>>()
    };
    (&mut $vec:ident.$field:ident, $t:ty) => {
        (&mut $vec).into_iter().map(|elem| &mut elem.$field).collect::<$t>()
    };
}

#[macro_export]
macro_rules! uncollate_req {
    (&$vec:ident.$field:ident) => {
        (&$vec).into_iter().map(|elem| ::std::option::Option::ok_or(elem.$field.as_ref(), "value must not be None"))
            .collect::<::std::result::Result<::std::vec::Vec<_>,_>>()
    };
    (&$vec:ident.$field:ident, $t:ty) => {
        (&$vec).into_iter().map(|elem| ::std::option::Option::ok_or(elem.$field.as_ref(), "value must not be None"))
            .collect::<::std::result::Result<$t,_>>()
    };
    (&mut $vec:ident.$field:ident) => {
        (&mut $vec).into_iter().map(|elem| ::std::option::Option::ok_or(elem.$field.as_mut(), "value must not be None"))
            .collect::<::std::result::Result<::std::vec::Vec<_>,_>>()
    };
    (&mut $vec:ident.$field:ident, $t:ty) => {
        (&mut $vec).into_iter().map(|elem| ::std::option::Option::ok_or(elem.$field.as_mut(), "value must not be None"))
            .collect::<::std::result::Result<$t,_>>()
    };
}

#[cfg(test)]
mod tests {

    #[test]
    pub fn test_uncollate_by_ref() {
        struct Test {
            a: String,
        }
        let test = vec![
            Test { a: "Hello".into() },
            Test { a: "Goodbye".into() }
        ];
        let uncol = uncollate!(&test.a);
        assert_eq!(vec![&test[0].a, &test[1].a], uncol);
    }

    #[test]
    pub fn test_uncollate_req() {
        struct Test {
            a: Option<String>,
        }
        let test = vec![
            Test { a: Some("Hello".into())},
            Test { a: None}
        ];

        let uncol = uncollate_req!(&test.a);
        assert!(uncol.is_err());
    }
}