kindness 0.5.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
97
98
99
100
101
102
103
104
105

#[cfg(any(test, feature = "std"))]
pub mod iterators {
    use core::hash::Hash;
    use core::iter::FusedIterator;
    use hashbrown::{hash_map::*, HashTable};

    #[derive(Debug)]
    pub struct Unique<Item, A: allocator_api2::alloc::Allocator + Clone> {
        table: hashbrown::hash_table::IntoIter<(Item, usize), A>,
    }

    impl<Item, A: allocator_api2::alloc::Allocator + Clone> Unique<Item, A> {
        pub fn new(table: hashbrown::hash_table::IntoIter<(Item, usize), A>) -> Self {
            Self { table }
        }
    }

    impl<Item, A: allocator_api2::alloc::Allocator + Clone> ExactSizeIterator for Unique<Item, A> {}

    impl<Item, A: allocator_api2::alloc::Allocator + Clone> FusedIterator for Unique<Item, A> {}

    impl<Item, A: allocator_api2::alloc::Allocator + Clone> Iterator for Unique<Item, A> {
        type Item = Item;

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

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

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

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

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

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

    impl<K: Eq + Hash, Item, A: allocator_api2::alloc::Allocator + Clone> UniqueByKey<K, Item, A> {
        pub fn new(map: IntoValues<K, (Item, usize), A>) -> Self {
            Self { map }
        }
    }

    impl<K: Eq + Hash, Item, A: allocator_api2::alloc::Allocator + Clone> ExactSizeIterator
        for UniqueByKey<K, Item, A>
    {
    }

    impl<K: Eq + Hash, Item, A: allocator_api2::alloc::Allocator + Clone> FusedIterator
        for UniqueByKey<K, Item, A>
    {
    }

    impl<K: Eq + Hash, Item, A: allocator_api2::alloc::Allocator + Clone> Iterator
        for UniqueByKey<K, Item, A>
    {
        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)
        }
    }
}