kindness 0.4.0

Methods for returning random elements from an iterator.
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

#[cfg(any(test, feature = "std"))]
pub mod iterators {
    use core::iter::FusedIterator;

    #[derive(Debug)]
    /// An iterator adapter to filter out duplicate elements.
    pub struct Unique<K: Eq + std::hash::Hash> {
        map: std::collections::hash_map::IntoKeys<K, usize>,
    }

    impl<K: Eq + std::hash::Hash> Unique<K> {
        pub fn new(map: std::collections::hash_map::IntoKeys<K, usize>) -> Self {
            Self { map }
        }
    }

    impl<K: Eq + std::hash::Hash> ExactSizeIterator for Unique<K> {}

    impl<K: Eq + std::hash::Hash> FusedIterator for Unique<K> {}

    impl<K: Eq + std::hash::Hash> Iterator for Unique<K> {
        type Item = K;

        fn next(&mut self) -> Option<Self::Item> {
            self.map.next()
        }

        fn size_hint(&self) -> (usize, Option<usize>) {
            self.map.size_hint()
        }

        fn count(self) -> usize
        where
            Self: Sized,
        {
            self.map.count()
        }

        fn last(self) -> Option<Self::Item>
        where
            Self: Sized,
        {
            self.map.last()
        }

        fn nth(&mut self, n: usize) -> Option<Self::Item> {
            self.map.nth(n)
        }
    }

    #[derive(Debug)]
    /// An iterator adapter to filter out duplicate elements by a key.
    pub struct UniqueByKey<K: Eq + std::hash::Hash, Item> {
        map: std::collections::hash_map::IntoValues<K, (Item, usize)>,
    }

    impl<K: Eq + std::hash::Hash, Item> UniqueByKey<K, Item> {
        pub fn new(map: std::collections::hash_map::IntoValues<K, (Item, usize)>) -> Self {
            Self { map }
        }
    }

    impl<K: Eq + std::hash::Hash, Item> ExactSizeIterator for UniqueByKey<K, Item> {}

    impl<K: Eq + std::hash::Hash, Item> FusedIterator for UniqueByKey<K, Item> {}

    impl<K: Eq + std::hash::Hash, Item> Iterator for UniqueByKey<K, Item> {
        type Item = Item;

        fn next(&mut self) -> Option<Self::Item> {
            self.map.next().map(|x| x.0)
        }

        fn size_hint(&self) -> (usize, Option<usize>) {
            self.map.size_hint()
        }

        fn count(self) -> usize
        where
            Self: Sized,
        {
            self.map.count()
        }

        fn last(self) -> Option<Self::Item>
        where
            Self: Sized,
        {
            self.map.map(|x| x.0).last()
        }

        fn nth(&mut self, n: usize) -> Option<Self::Item> {
            self.map.nth(n).map(|x| x.0)
        }
    }
}