easier 0.3.0

making rust easier
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
133
134
135
136
137

//finalises into a vec
pub(crate) trait SortVecExtension: Iterator {
    fn sort_vec(self) -> Vec<Self::Item>
    where
        Self::Item: Ord;

    ///Sort descending of an iterator and converting it to a Vec in one step
    fn sort_desc_vec(self) -> Vec<Self::Item>
    where
        Self::Item: Ord;

    fn sort_by_vec<F>(self, f: F) -> Vec<Self::Item>
    where
        F: FnMut(&Self::Item, &Self::Item) -> std::cmp::Ordering;
}

impl<I> SortVecExtension for I
where
    I: Iterator,
{
    fn sort_by_vec<F>(self, mut f: F) -> Vec<Self::Item>
    where
        F: FnMut(&Self::Item, &Self::Item) -> std::cmp::Ordering,
    {
        let mut iter: Vec<Self::Item> = self.collect();
        iter.sort_by(|a, b| f(a, b));
        iter
    }

    fn sort_vec(self) -> Vec<Self::Item>
    where
        Self::Item: Ord,
    {
        {
            let mut vec = self.collect::<Vec<_>>();
            vec.sort();
            vec
        }
    }

    fn sort_desc_vec(self) -> Vec<Self::Item>
    where
        Self::Item: Ord,
    {
        let mut vec = self.sort_vec();
        vec.reverse();
        vec
    }
}

//Continues as an iterator
pub trait SortExtension: Iterator {
    /// Sorting ascending of an iterator
    /// <br/>Note, this first converts to Vec, then converts back to iterator
    /// ```rust
    /// use easier::prelude::*;
    /// let vec = [4, 1, 3, 5, 2];
    /// assert_eq!(vec.into_iter().sort().to_vec(), vec![1, 2, 3, 4, 5]);
    /// ```
    fn sort(self) -> std::vec::IntoIter<<Self as Iterator>::Item>
    where
        Self::Item: Ord,
        Self: Sized,
    {
        self.sort_vec().into_iter()
    }

    /// Sorting descending of an iterator  
    /// <br/>Note, this first converts to Vec, then converts back to iterator
    fn sort_desc(self) -> std::vec::IntoIter<<Self as Iterator>::Item>
    where
        Self::Item: Ord,
        Self: Sized,
    {
        self.sort_desc_vec().into_iter()
    }

    /// Sorting by of an iterator  
    /// <br/>Note, this first converts to Vec, then converts back to iterator
    /// ```rust
    /// use easier::prelude::*;
    /// let a = vec![4., 1., 3., 5., 2.];
    /// assert_eq!(a.into_iter().sort_by(|a, b| a.partial_cmp(b).unwrap()).to_vec(),vec![1., 2., 3., 4., 5.] );
    /// ```
    fn sort_by<F>(self, f: F) -> std::vec::IntoIter<<Self as Iterator>::Item>
    where
        F: FnMut(&Self::Item, &Self::Item) -> std::cmp::Ordering,
        Self: Sized,
    {
        self.sort_by_vec(f).into_iter()
    }
}

impl<I> SortExtension for I where I: Iterator {}

#[cfg(test)]
mod test {
    use crate::prelude::*;
    #[test]
    fn sorting() {
        let a = vec![4, 1, 3, 5, 2];
        assert_eq!(a.iter().cloned().sort_vec(), vec![1, 2, 3, 4, 5]);
        assert_eq!(a.iter().cloned().sort_desc_vec(), vec![5, 4, 3, 2, 1]);
        assert_eq!(
            a.iter().cloned().sort_by_vec(|a, b| b.cmp(a)),
            vec![5, 4, 3, 2, 1]
        );
    }

    #[test]
    fn sorting_by() {
        let a = vec![4., 1., 3., 5., 2.];

        assert_eq!(
            a.iter()
                .cloned()
                .sort_by_vec(|a, b| a.partial_cmp(b).unwrap()),
            vec![1., 2., 3., 4., 5.]
        );
        assert_eq!(
            a.into_iter().sort_by_vec(|a, b| b.partial_cmp(a).unwrap()),
            vec![5., 4., 3., 2., 1.]
        );
    }

    #[test]
    fn readme() {
        let vec = vec![3, 2, 1];
        let sorted_and_filtered = vec.iter().sort().filter(|a| a > &&1).to_vec();
        assert_eq!(sorted_and_filtered, vec![&2, &3]);

        let mut sorted = vec.iter().collect::<Vec<_>>();
        sorted.sort();
        let filtered = sorted.into_iter().filter(|a| a > &&1).collect::<Vec<_>>();
        assert_eq!(filtered, vec![&2, &3]);
    }
}