Add unique_[by_]with_hasher()

Author: 424ever

src/lib.rs

@@ -1419,7 +1419,7 @@ pub trait Itertools: Iterator {
     /// Setting it manually using this function can expose a DoS attack vector.
     ///
     /// ```
-    /// use ahash::RandomState;
+    /// use std::hash::RandomState;
     /// use itertools::Itertools;
     ///
     /// let data = vec![10, 20, 30, 20, 40, 10, 50];
@@ -1464,15 +1464,15 @@ pub trait Itertools: Iterator {
     }
 
     /// Return an iterator which yields the same elements as the one returned by
-    /// [.duplicates()](crate::Itertools::duplicates), but uses the specified hash builder to hash
-    /// the keys for comparison.
+    /// [.duplicates_by()](crate::Itertools::duplicates_by), but uses the specified hash builder to
+    /// hash the keys for comparison.
     ///
     /// Warning: `hash_builder` is normally randomly generated, and is designed to allow it's
     /// users to be resistant to attacks that cause many collisions and very poor performance.
     /// Setting it manually using this function can expose a DoS attack vector.
     ///
     /// ```
-    /// use ahash::RandomState;
+    /// use std::hash::RandomState;
     /// use itertools::Itertools;
     ///
     /// let data = vec!["a", "bb", "aa", "c", "ccc"];
@@ -1518,7 +1518,33 @@ pub trait Itertools: Iterator {
         Self: Sized,
         Self::Item: Clone + Eq + Hash,
     {
-        unique_impl::unique(self)
+        unique_impl::unique_with_hasher(self, RandomState::new())
+    }
+
+    /// Return an iterator which yields the same elements as the one returned by
+    /// [.unique()](crate::Itertools::unique), but uses the specified hash builder to hash the
+    /// elements for comparison.
+    ///
+    /// Warning: `hash_builder` is normally randomly generated, and is designed to allow it's
+    /// users to be resistant to attacks that cause many collisions and very poor performance.
+    /// Setting it manually using this function can expose a DoS attack vector.
+    ///
+    /// ```
+    /// use std::hash::RandomState;
+    /// use itertools::Itertools;
+    ///
+    /// let data = vec![10, 20, 30, 20, 40, 10, 50];
+    /// itertools::assert_equal(data.into_iter().unique_with_hasher(RandomState::new()),
+    ///                         vec![10, 20, 30, 40, 50]);
+    /// ```
+    #[cfg(feature = "use_std")]
+    fn unique_with_hasher<S>(self, hash_builder: S) -> Unique<Self, S>
+    where
+        Self: Sized,
+        Self::Item: Clone + Eq + Hash,
+        S: BuildHasher,
+    {
+        unique_impl::unique_with_hasher(self, hash_builder)
     }
 
     /// Return an iterator adaptor that filters out elements that have
@@ -1546,7 +1572,34 @@ pub trait Itertools: Iterator {
         V: Eq + Hash,
         F: FnMut(&Self::Item) -> V,
     {
-        unique_impl::unique_by(self, f)
+        unique_impl::unique_by_with_hasher(self, f, RandomState::new())
+    }
+
+    /// Return an iterator which yields the same elements as the one returned by
+    /// [.unique_by()](crate::Itertools::unique_by), but uses the specified hash builder to hash
+    /// the elements for comparison.
+    ///
+    /// Warning: `hash_builder` is normally randomly generated, and is designed to allow it's
+    /// users to be resistant to attacks that cause many collisions and very poor performance.
+    /// Setting it manually using this function can expose a DoS attack vector.
+    ///
+    /// ```
+    /// use std::hash::RandomState;
+    /// use itertools::Itertools;
+    ///
+    /// let data = vec!["a", "bb", "aa", "c", "ccc"];
+    /// itertools::assert_equal(data.into_iter().unique_by_with_hasher(|s| s.len(), RandomState::new()),
+    ///                         vec!["a", "bb", "ccc"]);
+    /// ```
+    #[cfg(feature = "use_std")]
+    fn unique_by_with_hasher<V, F, S>(self, f: F, hash_builder: S) -> UniqueBy<Self, V, F, S>
+    where
+        Self: Sized,
+        V: Eq + Hash,
+        F: FnMut(&Self::Item) -> V,
+        S: BuildHasher,
+    {
+        unique_impl::unique_by_with_hasher(self, f, hash_builder)
     }
 
     /// Return an iterator adaptor that borrows from this iterator and

src/unique_impl.rs

@@ -1,62 +1,70 @@
+use core::hash::BuildHasher;
 use std::collections::hash_map::Entry;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fmt;
-use std::hash::Hash;
+use std::hash::{Hash, RandomState};
 use std::iter::FusedIterator;
 
 /// An iterator adapter to filter out duplicate elements.
 ///
 /// See [`.unique_by()`](crate::Itertools::unique) for more information.
 #[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct UniqueBy<I: Iterator, V, F> {
+pub struct UniqueBy<I: Iterator, V, F, S = RandomState>
+where
+    S: BuildHasher,
+{
     iter: I,
     // Use a Hashmap for the Entry API in order to prevent hashing twice.
     // This can maybe be replaced with a HashSet once `get_or_insert_with`
     // or a proper Entry API for Hashset is stable and meets this msrv
-    used: HashMap<V, ()>,
+    used: HashMap<V, (), S>,
     f: F,
 }
 
-impl<I, V, F> fmt::Debug for UniqueBy<I, V, F>
+impl<I, V, F, S> fmt::Debug for UniqueBy<I, V, F, S>
 where
     I: Iterator + fmt::Debug,
     V: fmt::Debug + Hash + Eq,
+    S: BuildHasher,
 {
     debug_fmt_fields!(UniqueBy, iter, used);
 }
 
 /// Create a new `UniqueBy` iterator.
-pub fn unique_by<I, V, F>(iter: I, f: F) -> UniqueBy<I, V, F>
+pub fn unique_by_with_hasher<I, V, F, S>(iter: I, f: F, hash_builder: S) -> UniqueBy<I, V, F, S>
 where
     V: Eq + Hash,
     F: FnMut(&I::Item) -> V,
     I: Iterator,
+    S: BuildHasher,
 {
     UniqueBy {
         iter,
-        used: HashMap::new(),
+        used: HashMap::with_hasher(hash_builder),
         f,
     }
 }
 
 // count the number of new unique keys in iterable (`used` is the set already seen)
-fn count_new_keys<I, K>(mut used: HashMap<K, ()>, iterable: I) -> usize
+fn count_new_keys<I, K, S>(mut used: HashMap<K, (), S>, iterable: I) -> usize
 where
     I: IntoIterator<Item = K>,
     K: Hash + Eq,
+    S: BuildHasher,
 {
     let iter = iterable.into_iter();
     let current_used = used.len();
     used.extend(iter.map(|key| (key, ())));
     used.len() - current_used
 }
 
-impl<I, V, F> Iterator for UniqueBy<I, V, F>
+impl<I, V, F, S> Iterator for UniqueBy<I, V, F, S>
 where
     I: Iterator,
     V: Eq + Hash,
     F: FnMut(&I::Item) -> V,
+    S: BuildHasher,
 {
     type Item = I::Item;
 
@@ -77,30 +85,33 @@ where
     }
 }
 
-impl<I, V, F> DoubleEndedIterator for UniqueBy<I, V, F>
+impl<I, V, F, S> DoubleEndedIterator for UniqueBy<I, V, F, S>
 where
     I: DoubleEndedIterator,
     V: Eq + Hash,
     F: FnMut(&I::Item) -> V,
+    S: BuildHasher,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         let Self { iter, used, f } = self;
         iter.rfind(|v| used.insert(f(v), ()).is_none())
     }
 }
 
-impl<I, V, F> FusedIterator for UniqueBy<I, V, F>
+impl<I, V, F, S> FusedIterator for UniqueBy<I, V, F, S>
 where
     I: FusedIterator,
     V: Eq + Hash,
     F: FnMut(&I::Item) -> V,
+    S: BuildHasher,
 {
 }
 
-impl<I> Iterator for Unique<I>
+impl<I, S> Iterator for Unique<I, S>
 where
     I: Iterator,
     I::Item: Eq + Hash + Clone,
+    S: BuildHasher,
 {
     type Item = I::Item;
 
@@ -127,10 +138,11 @@ where
     }
 }
 
-impl<I> DoubleEndedIterator for Unique<I>
+impl<I, S> DoubleEndedIterator for Unique<I, S>
 where
     I: DoubleEndedIterator,
     I::Item: Eq + Hash + Clone,
+    S: BuildHasher,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         let UniqueBy { iter, used, .. } = &mut self.iter;
@@ -145,10 +157,11 @@ where
     }
 }
 
-impl<I> FusedIterator for Unique<I>
+impl<I, S> FusedIterator for Unique<I, S>
 where
     I: FusedIterator,
     I::Item: Eq + Hash + Clone,
+    S: BuildHasher,
 {
 }
 
@@ -157,31 +170,34 @@ where
 /// See [`.unique()`](crate::Itertools::unique) for more information.
 #[derive(Clone)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct Unique<I>
+pub struct Unique<I, S = RandomState>
 where
     I: Iterator,
     I::Item: Eq + Hash + Clone,
+    S: BuildHasher,
 {
-    iter: UniqueBy<I, I::Item, ()>,
+    iter: UniqueBy<I, I::Item, (), S>,
 }
 
-impl<I> fmt::Debug for Unique<I>
+impl<I, S> fmt::Debug for Unique<I, S>
 where
     I: Iterator + fmt::Debug,
     I::Item: Hash + Eq + fmt::Debug + Clone,
+    S: BuildHasher,
 {
     debug_fmt_fields!(Unique, iter);
 }
 
-pub fn unique<I>(iter: I) -> Unique<I>
+pub fn unique_with_hasher<I, S>(iter: I, hash_builder: S) -> Unique<I, S>
 where
     I: Iterator,
     I::Item: Eq + Hash + Clone,
+    S: BuildHasher,
 {
     Unique {
         iter: UniqueBy {
             iter,
-            used: HashMap::new(),
+            used: HashMap::with_hasher(hash_builder),
             f: (),
         },
     }