collected 0.4.0

Summation, product, maximum and more special collectors for Rust iterators.
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

use crate::common::*;

/// A wrapper around collection `U` that retains only last `N` values.
#[derive(Debug, Clone)]
pub struct LastN<U, A, const N: usize>
where
    U: FromIterator<A>,
{
    buffer: VecDeque<A>,
    _phantom: PhantomData<U>,
}

impl<U, A, const N: usize> LastN<U, A, N>
where
    U: FromIterator<A>,
{
    /// Collects last `N` values into the collection `U`.
    pub fn into_inner(self) -> U {
        self.buffer.into_iter().collect()
    }
}

impl<U, A, const N: usize> FromIterator<A> for LastN<U, A, N>
where
    U: FromIterator<A>,
{
    fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self {
        let mut buffer = VecDeque::new();
        let mut iter = iter.into_iter();

        for item in &mut iter {
            buffer.push_back(item);
            if buffer.len() > N {
                buffer.pop_front();
                break;
            }
        }

        for item in iter {
            buffer.push_back(item);
            buffer.pop_front();
        }

        Self {
            buffer,
            _phantom: PhantomData,
        }
    }
}

impl<U, A, const N: usize> Default for LastN<U, A, N>
where
    U: FromIterator<A>,
{
    fn default() -> Self {
        Self {
            buffer: VecDeque::new(),
            _phantom: PhantomData,
        }
    }
}

impl<U, A, const N: usize> Extend<A> for LastN<U, A, N>
where
    U: FromIterator<A>,
{
    fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) {
        let mut iter = iter.into_iter();

        for item in &mut iter {
            self.buffer.push_back(item);
            if self.buffer.len() > N {
                self.buffer.pop_front();
                break;
            }
        }

        for item in iter {
            self.buffer.push_back(item);
            self.buffer.pop_front();
        }
    }
}

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

    #[test]
    fn last_n_test() {
        let last_n: LastN<Vec<_>, _, 3> = vec![3, 1, 5, 2].into_iter().collect();
        assert_eq!(last_n.into_inner(), vec![1, 5, 2]);

        let last_n: LastN<Vec<_>, usize, 3> = vec![].into_iter().collect();
        assert_eq!(last_n.into_inner(), vec![]);

        let last_n: LastN<Vec<_>, _, 0> = vec![2, 4, 1].into_iter().collect();
        assert_eq!(last_n.into_inner(), vec![]);
    }
}