Improve ExactlyOneError

src/exactly_one_err.rs

@@ -1,3 +1,5 @@
+use std::iter::ExactSizeIterator;
+
 use size_hint;
 
 /// Iterator returned for the error case of `IterTools::exactly_one()`
@@ -9,31 +11,31 @@ use size_hint;
 /// This is very similar to PutBackN except this iterator only supports 0-2 elements and does not
 /// use a `Vec`.
 #[derive(Debug, Clone)]
-pub struct ExactlyOneErr<T, I>
+pub struct ExactlyOneError<I>
 where
-    I: Iterator<Item = T>,
+    I: Iterator,
 {
-    first_two: (Option<T>, Option<T>),
+    first_two: (Option<I::Item>, Option<I::Item>),
     inner: I,
 }
 
-impl<T, I> ExactlyOneErr<T, I>
+impl<I> ExactlyOneError<I>
 where
-    I: Iterator<Item = T>,
+    I: Iterator,
 {
     /// Creates a new `ExactlyOneErr` iterator.
-    pub fn new(first_two: (Option<T>, Option<T>), inner: I) -> Self {
+    pub fn new(first_two: (Option<I::Item>, Option<I::Item>), inner: I) -> Self {
         Self { first_two, inner }
     }
 }
 
-impl<T, I> Iterator for ExactlyOneErr<T, I>
+impl<I> Iterator for ExactlyOneError<I>
 where
-    I: Iterator<Item = T>,
+    I: Iterator,
 {
-    type Item = T;
+    type Item = I::Item;
 
-    fn next(&mut self) -> Option<T> {
+    fn next(&mut self) -> Option<Self::Item> {
         self.first_two
             .0
             .take()
@@ -52,3 +54,5 @@ where
         size_hint::add_scalar(self.inner.size_hint(), additional_len)
     }
 }
+
+impl<I> ExactSizeIterator for ExactlyOneError<I> where I: ExactSizeIterator {}

src/lib.rs

@@ -74,7 +74,7 @@ pub mod structs {
     #[cfg(feature = "use_std")]
     pub use combinations::Combinations;
     pub use cons_tuples_impl::ConsTuples;
-    pub use exactly_one_err::ExactlyOneErr;
+    pub use exactly_one_err::ExactlyOneError;
     pub use format::{Format, FormatWith};
     #[cfg(feature = "use_std")]
     pub use groupbylazy::{IntoChunks, Chunk, Chunks, GroupBy, Group, Groups};
@@ -2003,22 +2003,22 @@ pub trait Itertools : Iterator {
     /// assert!((0..10).filter(|&x| x > 1 && x < 5).exactly_one().unwrap_err().eq(2..5));
     /// assert!((0..10).filter(|&x| false).exactly_one().unwrap_err().eq(0..0));
     /// ```
-    fn exactly_one(mut self) -> Result<Self::Item, ExactlyOneErr<Self::Item, Self>>
+    fn exactly_one(mut self) -> Result<Self::Item, ExactlyOneError<Self>>
     where
         Self: Sized,
     {
         match self.next() {
             Some(first) => {
                 match self.next() {
                     Some(second) => {
-                        Err(ExactlyOneErr::new((Some(first), Some(second)), self))
+                        Err(ExactlyOneError::new((Some(first), Some(second)), self))
                     }
                     None => {
                         Ok(first)
                     }
                 }
             }
-            None => Err(ExactlyOneErr::new((None, None), self)),
+            None => Err(ExactlyOneError::new((None, None), self)),
         }
     }
 }