Unique: Edit docs & remove clone bound, fix size_hint

Author: root

src/adaptors.rs

@@ -975,7 +975,7 @@ impl<I> Iterator for Combinations<I> where I: Iterator + Clone, I::Item: Clone{
     }
 }
 
-/// An iterator adapter to filter non-unique elements.
+/// An iterator adapter to filter out duplicate elements.
 ///
 /// See [*.unique()*](trait.Itertools.html#method.unique) for more information.
 #[derive(Clone)]
@@ -985,7 +985,10 @@ pub struct UniqueBy<I: Iterator, V, F> {
     f: F,
 }
 
-impl<I: Iterator, V, F> UniqueBy<I, V, F> where V: Clone + Eq + Hash, F: FnMut(&I::Item) -> V {
+impl<I: Iterator, V, F> UniqueBy<I, V, F>
+    where V: Eq + Hash,
+          F: FnMut(&I::Item) -> V
+{
     /// Create a new **UniqueBy** iterator.
     pub fn new(iter: I, f: F) -> UniqueBy<I, V, F> {
         UniqueBy {
@@ -998,7 +1001,7 @@ impl<I: Iterator, V, F> UniqueBy<I, V, F> where V: Clone + Eq + Hash, F: FnMut(&
 
 impl<I, V, F> Iterator for UniqueBy<I, V, F> where
     I: Iterator,
-    V: Clone + Eq + Hash,
+    V: Eq + Hash,
     F: FnMut(&I::Item) -> V
 {
     type Item = I::Item;
@@ -1019,10 +1022,11 @@ impl<I, V, F> Iterator for UniqueBy<I, V, F> where
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, self.iter.size_hint().1)
+        let (low, hi) = self.iter.size_hint();
+        ((low > 0 && self.used.is_empty()) as usize, hi)
     }
 }
 
-/// An iterator adapter to filter non-unique elements.
+/// An iterator adapter to filter out duplicate elements.
 pub type Unique<I> where I: Iterator =
     UniqueBy<I, I::Item, fn(&I::Item) -> I::Item>;

src/lib.rs

@@ -628,9 +628,11 @@ pub trait Itertools : Iterator {
         Coalesce::new(self, eq)
     }
 
-    /// Filter non-unique elements from the iterator.
+    /// Return an iterator adaptor that filters out elements that have
+    /// already been produced once during the iteration. Duplicates
+    /// are detected using hash and equality.
     ///
-    /// Copies of visited elements are stored in a hash set in the
+    /// Clones of visited elements are stored in a hash set in the
     /// iterator.
     ///
     /// ```
@@ -647,11 +649,12 @@ pub trait Itertools : Iterator {
         self.unique_by(Clone::clone)
     }
 
-    /// Filter non-unique elements from the iterator.
+    /// Return an iterator adaptor that filters out elements that have
+    /// already been produced once during the iteration.
     ///
-    /// Elemens are considered the same if supplied function returns
-    /// equal values for them. Those values are stored in a hash set in
-    /// the iterator.
+    /// Duplicates are detected by comparing the key they map to
+    /// with the keying function **f** by hash and equality.
+    /// The keys are stored in a hash set in the iterator.
     ///
     /// ```
     /// use itertools::Itertools;
@@ -662,7 +665,7 @@ pub trait Itertools : Iterator {
     /// ```
     fn unique_by<V, F>(self, f: F) -> UniqueBy<Self, V, F> where
         Self: Sized,
-        V: Clone + Eq + Hash,
+        V: Eq + Hash,
         F: FnMut(&Self::Item) -> V
     {
         UniqueBy::new(self, f)

tests/quick.rs

@@ -467,4 +467,9 @@ fn size_pad_tail2(it: Iter<i8>, pad: u8) -> bool {
     exact_size(it.pad_using(pad as usize, |_| 0))
 }
 
+#[quickcheck]
+fn size_unique(it: Iter<i8>) -> bool {
+    correct_size_hint(it.unique())
+}
+
 }