removed formats for pullreq

Author: Sagebati

src/lib.rs

@@ -63,10 +63,10 @@ use std::fmt;
 use std::hash::Hash;
 #[cfg(feature = "use_std")]
 use std::fmt::Write;
-
 #[cfg(feature = "use_std")]
 type VecIntoIter<T> = ::std::vec::IntoIter<T>;
-
+#[cfg(feature = "use_std")]
+type HashMapIntoIter<K, V> = ::std::collections::hash_map::IntoIter<K, V>;
 use std::iter::FromIterator;
 
 #[macro_use]
@@ -151,7 +151,7 @@ pub use cons_tuples_impl::cons_tuples;
 pub use diff::diff_with;
 pub use diff::Diff;
 #[cfg(feature = "use_std")]
-pub use kmerge_impl::kmerge_by;
+pub use kmerge_impl::{kmerge_by};
 pub use minmax::MinMaxResult;
 pub use peeking_take_while::PeekingNext;
 pub use process_results_impl::process_results;
@@ -160,18 +160,13 @@ pub use repeatn::repeat_n;
 pub use sources::{repeat_call, unfold, iterate};
 pub use with_position::Position;
 pub use ziptuple::multizip;
-
 mod adaptors;
 mod either_or_both;
-
 pub use either_or_both::EitherOrBoth;
-
 #[doc(hidden)]
 pub mod free;
-
 #[doc(inline)]
 pub use free::*;
-
 mod concat_impl;
 mod cons_tuples_impl;
 #[cfg(feature = "use_std")]
@@ -353,7 +348,7 @@ macro_rules! izip {
 /// method in the list.
 ///
 /// [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
-pub trait Itertools: Iterator {
+pub trait Itertools : Iterator {
     // adaptors
 
     /// Alternate elements from two iterators until both have run out.
@@ -369,7 +364,7 @@ pub trait Itertools: Iterator {
     /// itertools::assert_equal(it, vec![1, -1, 2, -2, 3, 4, 5, 6]);
     /// ```
     fn interleave<J>(self, other: J) -> Interleave<Self, J::IntoIter>
-        where J: IntoIterator<Item=Self::Item>,
+        where J: IntoIterator<Item = Self::Item>,
               Self: Sized
     {
         interleave(self, other)
@@ -387,7 +382,7 @@ pub trait Itertools: Iterator {
     /// itertools::assert_equal(it, vec![1, -1, 2, -2, 3]);
     /// ```
     fn interleave_shortest<J>(self, other: J) -> InterleaveShortest<Self, J::IntoIter>
-        where J: IntoIterator<Item=Self::Item>,
+        where J: IntoIterator<Item = Self::Item>,
               Self: Sized
     {
         adaptors::interleave_shortest(self, other.into_iter())
@@ -599,7 +594,7 @@ pub trait Itertools: Iterator {
     /// itertools::assert_equal(it, vec![(1, 2, 3), (2, 3, 4)]);
     /// ```
     fn tuple_windows<T>(self) -> TupleWindows<Self, T>
-        where Self: Sized + Iterator<Item=T::Item>,
+        where Self: Sized + Iterator<Item = T::Item>,
               T: traits::HomogeneousTuple,
               T::Item: Clone
     {
@@ -638,7 +633,7 @@ pub trait Itertools: Iterator {
     ///
     /// See also [`Tuples::into_buffer`](structs/struct.Tuples.html#method.into_buffer).
     fn tuples<T>(self) -> Tuples<Self, T>
-        where Self: Sized + Iterator<Item=T::Item>,
+        where Self: Sized + Iterator<Item = T::Item>,
               T: traits::HomogeneousTuple
     {
         tuple_impl::tuples(self)
@@ -719,7 +714,7 @@ pub trait Itertools: Iterator {
     /// itertools::assert_equal(it, vec![Ok(42), Err(false), Ok(12)]);
     /// ```
     fn map_results<F, T, U, E>(self, f: F) -> MapResults<Self, F>
-        where Self: Iterator<Item=Result<T, E>> + Sized,
+        where Self: Iterator<Item = Result<T, E>> + Sized,
               F: FnMut(T) -> U,
     {
         adaptors::map_results(self, f)
@@ -742,7 +737,7 @@ pub trait Itertools: Iterator {
     fn merge<J>(self, other: J) -> Merge<Self, J::IntoIter>
         where Self: Sized,
               Self::Item: PartialOrd,
-              J: IntoIterator<Item=Self::Item>
+              J: IntoIterator<Item = Self::Item>
     {
         merge(self, other)
     }
@@ -765,7 +760,7 @@ pub trait Itertools: Iterator {
 
     fn merge_by<J, F>(self, other: J, is_first: F) -> MergeBy<Self, J::IntoIter, F>
         where Self: Sized,
-              J: IntoIterator<Item=Self::Item>,
+              J: IntoIterator<Item = Self::Item>,
               F: FnMut(&Self::Item, &Self::Item) -> bool
     {
         adaptors::merge_by_new(self, other.into_iter(), is_first)
@@ -954,7 +949,7 @@ pub trait Itertools: Iterator {
     fn coalesce<F>(self, f: F) -> Coalesce<Self, F>
         where Self: Sized,
               F: FnMut(Self::Item, Self::Item)
-                  -> Result<Self::Item, (Self::Item, Self::Item)>
+                       -> Result<Self::Item, (Self::Item, Self::Item)>
     {
         adaptors::coalesce(self, f)
     }
@@ -1106,7 +1101,7 @@ pub trait Itertools: Iterator {
     ///
     /// ```
     fn while_some<A>(self) -> WhileSome<Self>
-        where Self: Sized + Iterator<Item=Option<A>>
+        where Self: Sized + Iterator<Item = Option<A>>
     {
         adaptors::while_some(self)
     }
@@ -1210,9 +1205,9 @@ pub trait Itertools: Iterator {
     /// ```
     #[cfg(feature = "use_std")]
     fn combinations_with_replacement(self, k: usize) -> CombinationsWithReplacement<Self>
-        where
-            Self: Sized,
-            Self::Item: Clone,
+    where
+        Self: Sized,
+        Self::Item: Clone,
     {
         combinations_with_replacement::combinations_with_replacement(self, k)
     }
@@ -1363,7 +1358,7 @@ pub trait Itertools: Iterator {
     /// assert_eq!(Some((1, 2)), iter.next_tuple());
     /// ```
     fn next_tuple<T>(&mut self) -> Option<T>
-        where Self: Sized + Iterator<Item=T::Item>,
+        where Self: Sized + Iterator<Item = T::Item>,
               T: traits::HomogeneousTuple
     {
         T::collect_from_iter_no_buf(self)
@@ -1388,7 +1383,7 @@ pub trait Itertools: Iterator {
     /// }
     /// ```
     fn collect_tuple<T>(mut self) -> Option<T>
-        where Self: Sized + Iterator<Item=T::Item>,
+        where Self: Sized + Iterator<Item = T::Item>,
               T: traits::HomogeneousTuple
     {
         match self.next_tuple() {
@@ -1575,9 +1570,9 @@ pub trait Itertools: Iterator {
     /// ```
     #[cfg(feature = "use_std")]
     fn try_collect<T, U, E>(self) -> Result<U, E>
-        where
-            Self: Sized + Iterator<Item=Result<T, E>>,
-            Result<U, E>: FromIterator<Result<T, E>>,
+    where
+        Self: Sized + Iterator<Item = Result<T, E>>,
+        Result<U, E>: FromIterator<Result<T, E>>,
     {
         self.collect()
     }
@@ -1599,8 +1594,8 @@ pub trait Itertools: Iterator {
     /// ```
     #[inline]
     fn set_from<'a, A: 'a, J>(&mut self, from: J) -> usize
-        where Self: Iterator<Item=&'a mut A>,
-              J: IntoIterator<Item=A>
+        where Self: Iterator<Item = &'a mut A>,
+              J: IntoIterator<Item = A>
     {
         let mut count = 0;
         for elt in from {
@@ -1746,7 +1741,7 @@ pub trait Itertools: Iterator {
     /// );
     /// ```
     fn fold_results<A, E, B, F>(&mut self, mut start: B, mut f: F) -> Result<B, E>
-        where Self: Iterator<Item=Result<A, E>>,
+        where Self: Iterator<Item = Result<A, E>>,
               F: FnMut(B, A) -> B
     {
         for elt in self {
@@ -1778,7 +1773,7 @@ pub trait Itertools: Iterator {
     /// assert_eq!(more_values.next().unwrap(), Some(0));
     /// ```
     fn fold_options<A, B, F>(&mut self, mut start: B, mut f: F) -> Option<B>
-        where Self: Iterator<Item=Option<A>>,
+        where Self: Iterator<Item = Option<A>>,
               F: FnMut(B, A) -> B
     {
         for elt in self {
@@ -1865,23 +1860,25 @@ pub trait Itertools: Iterator {
 
         fn inner0<T, II, FF>(it: &mut II, f: &mut FF) -> State<T>
             where
-                II: Iterator<Item=T>,
+                II: Iterator<Item = T>,
                 FF: FnMut(T, T) -> T
         {
             // This function could be replaced with `it.next().ok_or(None)`,
             // but half the useful tree_fold1 work is combining adjacent items,
             // so put that in a form that LLVM is more likely to optimize well.
 
             let a =
-                if let Some(v) = it.next() { v } else { return Err(None); };
+                if let Some(v) = it.next() { v }
+                else { return Err(None) };
             let b =
-                if let Some(v) = it.next() { v } else { return Err(Some(a)); };
+                if let Some(v) = it.next() { v }
+                else { return Err(Some(a)) };
             Ok(f(a, b))
         }
 
         fn inner<T, II, FF>(stop: usize, it: &mut II, f: &mut FF) -> State<T>
             where
-                II: Iterator<Item=T>,
+                II: Iterator<Item = T>,
                 FF: FnMut(T, T) -> T
         {
             let mut x = inner0(it, f)?;
@@ -2193,8 +2190,9 @@ pub trait Itertools: Iterator {
     /// use std::collections::HashMap;
     ///
     /// let data = vec![(0, 10), (2, 12), (3, 13), (0, 20), (3, 33), (2, 42)];
-    /// let lookup: HashMap<u32,Vec<(u32, u32)>> =
-    ///     data.clone().into_iter().into_group_map_by(|a| a.0);
+    /// let lookup: HashMap<u32,Vec<(u32, u32)>> = data.clone().into_iter().into_group_map_by(|a|
+    /// a.0)
+    /// .collect();
     ///
     /// assert_eq!(lookup[&0], vec![(0,10),(0,20)]);
     /// assert_eq!(lookup.get(&1), None);
@@ -2204,12 +2202,11 @@ pub trait Itertools: Iterator {
     /// assert_eq!(
     ///     data.into_iter()
     ///     .into_group_map_by(|x| x.0)
-    ///     .into_iter()
     ///     .map(|(key, values)| (key, values.into_iter().fold(0,|acc, (_,v)| acc + v )))
     ///     .collect::<HashMap<u32,u32>>()[&0], 30)
     /// ```
     #[cfg(feature = "use_std")]
-    fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
+    fn into_group_map_by<K, V, F>(self, f: F) -> HashMapIntoIter<K, Vec<V>>
         where
             Self: Iterator<Item=V> + Sized,
             K: Hash + Eq,
@@ -2290,7 +2287,7 @@ pub trait Itertools: Iterator {
         minmax::minmax_impl(
             self,
             |_| (),
-            |x, y, _, _| Ordering::Less == compare(x, y),
+            |x, y, _, _| Ordering::Less == compare(x, y)
         )
     }
 
@@ -2312,8 +2309,8 @@ pub trait Itertools: Iterator {
     /// assert!((0..10).filter(|&_| false).exactly_one().unwrap_err().eq(0..0));
     /// ```
     fn exactly_one(mut self) -> Result<Self::Item, ExactlyOneError<Self>>
-        where
-            Self: Sized,
+    where
+        Self: Sized,
     {
         match self.next() {
             Some(first) => {
@@ -2331,7 +2328,7 @@ pub trait Itertools: Iterator {
     }
 }
 
-impl<T: ?Sized> Itertools for T where T: Iterator {}
+impl<T: ?Sized> Itertools for T where T: Iterator { }
 
 /// Return `true` if both iterables produce equal sequences
 /// (elements pairwise equal and sequences of the same length),
@@ -2415,7 +2412,7 @@ pub fn assert_equal<I, J>(a: I, b: J)
 /// assert_eq!(split_index, 3);
 /// ```
 pub fn partition<'a, A: 'a, I, F>(iter: I, mut pred: F) -> usize
-    where I: IntoIterator<Item=&'a mut A>,
+    where I: IntoIterator<Item = &'a mut A>,
           I::IntoIter: DoubleEndedIterator,
           F: FnMut(&A) -> bool
 {