Merged upstream

Author: SkiFire13

.travis.yml

@@ -2,33 +2,28 @@ language: rust
 sudo: false
 matrix:
   include:
-    - rust: 1.32.0
+    - rust: 1.36.0
       script:
         - |
             cargo build --verbose --no-default-features &&
+            cargo build --verbose --no-default-features --features "use_alloc" &&
             cargo build --verbose --features "$FEATURES"
     - rust: stable
       script:
         - |
             cargo build --verbose --no-default-features &&
+            cargo build --verbose --no-default-features --features "use_alloc" &&
             cargo build --verbose --features "$FEATURES" &&
             cargo test --verbose --features "$FEATURES" &&
             cargo bench --no-run --verbose --features "$FEATURES"
     - rust: beta
       script:
         - |
             cargo build --verbose --no-default-features &&
+            cargo build --verbose --no-default-features --features "use_alloc" &&
             cargo build --verbose --features "$FEATURES" &&
             cargo test --verbose --features "$FEATURES" &&
             cargo bench --no-run --verbose --features "$FEATURES"
-    - rust: nightly
-      script:
-        - |
-            cargo build --verbose --no-default-features &&
-            cargo build --verbose --features "$FEATURES" &&
-            cargo test --verbose --features "$FEATURES" &&
-            cargo bench --no-run --verbose --features "$FEATURES"
-cache: cargo # https://docs.travis-ci.com/user/languages/rust/#dependency-management
 branches:
   only:
     - master

Cargo.toml

@@ -38,7 +38,8 @@ version = "0.2"
 
 [features]
 default = ["use_std"]
-use_std = []
+use_std = ["use_alloc"]
+use_alloc = []
 
 [profile]
 bench = { debug = true }

src/adaptors/map.rs

@@ -68,7 +68,7 @@ where
 pub type MapOk<I, F> = MapSpecialCase<I, MapSpecialCaseFnOk<F>>;
 
 /// See [`MapOk`](struct.MapOk.html).
-#[deprecated(note = "Use MapOk instead", since = "0.10")]
+#[deprecated(note = "Use MapOk instead", since = "0.10.0")]
 pub type MapResults<I, F> = MapOk<I, F>;
 
 impl<F, T, U, E> MapSpecialCaseFn<Result<T, E>> for MapSpecialCaseFnOk<F>

src/adaptors/mod.rs

@@ -11,7 +11,7 @@ pub use self::coalesce::*;
 pub use self::map::{map_into, map_ok, MapInto, MapOk};
 #[allow(deprecated)]
 pub use self::map::MapResults;
-#[cfg(feature = "use_std")]
+#[cfg(feature = "use_alloc")]
 pub use self::multi_product::*;
 
 use std::fmt;
@@ -113,22 +113,11 @@ impl<I, J> Iterator for InterleaveShortest<I, J>
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        match self.phase {
-            false => match self.it0.next() {
-                None => None,
-                e => {
-                    self.phase = true;
-                    e
-                }
-            },
-            true => match self.it1.next() {
-                None => None,
-                e => {
-                    self.phase = false;
-                    e
-                }
-            },
+        let e = if self.phase { self.it1.next() } else { self.it0.next() };
+        if e.is_some() {
+            self.phase = !self.phase;
         }
+        e
     }
 
     #[inline]
@@ -412,7 +401,7 @@ impl<B, F, I> Iterator for Batching<I, F>
 /// then skipping forward *n-1* elements.
 ///
 /// See [`.step()`](../trait.Itertools.html#method.step) for more information.
-#[deprecated(note="Use std .step_by() instead", since="0.8")]
+#[deprecated(note="Use std .step_by() instead", since="0.8.0")]
 #[allow(deprecated)]
 #[derive(Clone, Debug)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
@@ -806,9 +795,30 @@ macro_rules! impl_tuple_combination {
     )
 }
 
-impl_tuple_combination!(Tuple2Combination Tuple1Combination ; A, A, A ; a);
-impl_tuple_combination!(Tuple3Combination Tuple2Combination ; A, A, A, A ; a b);
-impl_tuple_combination!(Tuple4Combination Tuple3Combination ; A, A, A, A, A; a b c);
+// This snippet generates the twelve `impl_tuple_combination!` invocations:
+//    use core::iter;
+//    use itertools::Itertools;
+//
+//    for i in 2..=12 {
+//        println!("impl_tuple_combination!(Tuple{arity}Combination Tuple{prev}Combination; {tys}; {idents});",
+//            arity = i,
+//            prev = i - 1,
+//            tys = iter::repeat("A").take(i + 1).join(", "),
+//            idents = ('a'..'z').take(i - 1).join(" "),
+//        );
+//    }
+// It could probably be replaced by a bit more macro cleverness.
+impl_tuple_combination!(Tuple2Combination Tuple1Combination; A, A, A; a);
+impl_tuple_combination!(Tuple3Combination Tuple2Combination; A, A, A, A; a b);
+impl_tuple_combination!(Tuple4Combination Tuple3Combination; A, A, A, A, A; a b c);
+impl_tuple_combination!(Tuple5Combination Tuple4Combination; A, A, A, A, A, A; a b c d);
+impl_tuple_combination!(Tuple6Combination Tuple5Combination; A, A, A, A, A, A, A; a b c d e);
+impl_tuple_combination!(Tuple7Combination Tuple6Combination; A, A, A, A, A, A, A, A; a b c d e f);
+impl_tuple_combination!(Tuple8Combination Tuple7Combination; A, A, A, A, A, A, A, A, A; a b c d e f g);
+impl_tuple_combination!(Tuple9Combination Tuple8Combination; A, A, A, A, A, A, A, A, A, A; a b c d e f g h);
+impl_tuple_combination!(Tuple10Combination Tuple9Combination; A, A, A, A, A, A, A, A, A, A, A; a b c d e f g h i);
+impl_tuple_combination!(Tuple11Combination Tuple10Combination; A, A, A, A, A, A, A, A, A, A, A, A; a b c d e f g h i j);
+impl_tuple_combination!(Tuple12Combination Tuple11Combination; A, A, A, A, A, A, A, A, A, A, A, A, A; a b c d e f g h i j k);
 
 /// An iterator adapter to filter values within a nested `Result::Ok`.
 ///

src/adaptors/multi_product.rs

@@ -1,8 +1,10 @@
-#![cfg(feature = "use_std")]
+#![cfg(feature = "use_alloc")]
 
 use crate::size_hint;
 use crate::Itertools;
 
+use alloc::vec::Vec;
+
 #[derive(Clone)]
 /// An iterator adaptor that iterates over the cartesian product of
 /// multiple iterators of type `I`.
@@ -161,7 +163,7 @@ impl<I> Iterator for MultiProduct<I>
     }
 
     fn count(self) -> usize {
-        if self.0.len() == 0 {
+        if self.0.is_empty() {
             return 0;
         }
 
@@ -183,7 +185,7 @@ impl<I> Iterator for MultiProduct<I>
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         // Not ExactSizeIterator because size may be larger than usize
-        if self.0.len() == 0 {
+        if self.0.is_empty() {
             return (0, Some(0));
         }
 

src/combinations.rs

@@ -1,6 +1,7 @@
 use std::fmt;
 
 use super::lazy_buffer::LazyBuffer;
+use alloc::vec::Vec;
 
 /// An iterator to iterate through all the `k`-length combinations in an iterator.
 ///
@@ -56,7 +57,7 @@ impl<I> Iterator for Combinations<I>
                 return None;
             }
             self.first = false;
-        } else if self.indices.len() == 0 {
+        } else if self.indices.is_empty() {
             return None;
         } else {
             // Scan from the end, looking for an index to increment

src/combinations_with_replacement.rs

@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use std::fmt;
 
 use super::lazy_buffer::LazyBuffer;
@@ -11,10 +12,7 @@ where
     I: Iterator,
     I::Item: Clone,
 {
-    k: usize,
     indices: Vec<usize>,
-    // The current known max index value. This increases as pool grows.
-    max_index: usize,
     pool: LazyBuffer<I>,
     first: bool,
 }
@@ -24,7 +22,7 @@ where
     I: Iterator + fmt::Debug,
     I::Item: fmt::Debug + Clone,
 {
-    debug_fmt_fields!(Combinations, k, indices, max_index, pool, first);
+    debug_fmt_fields!(Combinations, indices, pool, first);
 }
 
 impl<I> CombinationsWithReplacement<I>
@@ -44,13 +42,11 @@ where
     I: Iterator,
     I::Item: Clone,
 {
-    let indices: Vec<usize> = vec![0; k];
+    let indices: Vec<usize> = alloc::vec![0; k];
     let pool: LazyBuffer<I> = LazyBuffer::new(iter);
 
     CombinationsWithReplacement {
-        k,
         indices,
-        max_index: 0,
         pool,
         first: true,
     }
@@ -66,7 +62,7 @@ where
         // If this is the first iteration, return early
         if self.first {
             // In empty edge cases, stop iterating immediately
-            return if self.k != 0 && !self.pool.get_next() {
+            return if self.indices.len() != 0 && !self.pool.get_next() {
                 None
             // Otherwise, yield the initial state
             } else {
@@ -77,14 +73,12 @@ where
 
         // Check if we need to consume more from the iterator
         // This will run while we increment our first index digit
-        if self.pool.get_next() {
-            self.max_index = self.pool.len() - 1;
-        }
+        self.pool.get_next();
 
         // Work out where we need to update our indices
         let mut increment: Option<(usize, usize)> = None;
         for (i, indices_int) in self.indices.iter().enumerate().rev() {
-            if indices_int < &self.max_index {
+            if *indices_int < self.pool.len()-1 {
                 increment = Some((i, indices_int + 1));
                 break;
             }

src/concat_impl.rs

@@ -18,5 +18,5 @@ pub fn concat<I>(iterable: I) -> I::Item
     where I: IntoIterator,
           I::Item: Extend<<<I as IntoIterator>::Item as IntoIterator>::Item> + IntoIterator + Default
 {
-    iterable.into_iter().fold1(|mut a, b| { a.extend(b); a }).unwrap_or_else(|| <_>::default())
+    iterable.into_iter().fold1(|mut a, b| { a.extend(b); a }).unwrap_or_else(<_>::default)
 }

src/cons_tuples_impl.rs

@@ -35,7 +35,7 @@ macro_rules! impl_cons_iter(
     );
 );
 
-impl_cons_iter!(A, B, C, D, E, F, G, H,);
+impl_cons_iter!(A, B, C, D, E, F, G, H, I, J, K, L,);
 
 /// An iterator that maps an iterator of tuples like
 /// `((A, B), C)` to an iterator of `(A, B, C)`.
@@ -57,8 +57,8 @@ impl<I, J> Clone for ConsTuples<I, J>
 
 /// Create an iterator that maps for example iterators of
 /// `((A, B), C)` to `(A, B, C)`.
-pub fn cons_tuples<I, J>(iterable: I) -> ConsTuples<I, J>
-    where I: Iterator<Item=J>
+pub fn cons_tuples<I, J>(iterable: I) -> ConsTuples<I::IntoIter, J>
+    where I: IntoIterator<Item=J>
 {
     ConsTuples { iter: iterable.into_iter() }
 }

src/exactly_one_err.rs

@@ -1,5 +1,11 @@
+#[cfg(feature = "use_std")]
+use std::error::Error;
+use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
+
 use std::iter::ExactSizeIterator;
 
+use either::Either;
+
 use crate::size_hint;
 
 /// Iterator returned for the error case of `IterTools::exactly_one()`
@@ -10,12 +16,12 @@ use crate::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)]
+#[derive(Clone)]
 pub struct ExactlyOneError<I>
 where
     I: Iterator,
 {
-    first_two: (Option<I::Item>, Option<I::Item>),
+    first_two: Option<Either<[I::Item; 2], I::Item>>,
     inner: I,
 }
 
@@ -24,9 +30,17 @@ where
     I: Iterator,
 {
     /// Creates a new `ExactlyOneErr` iterator.
-    pub(crate) fn new(first_two: (Option<I::Item>, Option<I::Item>), inner: I) -> Self {
+    pub(crate) fn new(first_two: Option<Either<[I::Item; 2], I::Item>>, inner: I) -> Self {
         Self { first_two, inner }
     }
+
+    fn additional_len(&self) -> usize {
+        match self.first_two {
+            Some(Either::Left(_)) => 2,
+            Some(Either::Right(_)) => 1,
+            None => 0,
+        }
+    }
 }
 
 impl<I> Iterator for ExactlyOneError<I>
@@ -36,23 +50,61 @@ where
     type Item = I::Item;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.first_two
-            .0
-            .take()
-            .or_else(|| self.first_two.1.take())
-            .or_else(|| self.inner.next())
+        match self.first_two.take() {
+            Some(Either::Left([first, second])) => {
+                self.first_two = Some(Either::Right(second));
+                Some(first)
+            },
+            Some(Either::Right(second)) => {
+                Some(second)
+            }
+            None => {
+                self.inner.next()
+            }
+        }
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        let mut additional_len = 0;
-        if self.first_two.0.is_some() {
-            additional_len += 1;
+        size_hint::add_scalar(self.inner.size_hint(), self.additional_len())
+    }
+}
+
+
+impl<I> ExactSizeIterator for ExactlyOneError<I> where I: ExactSizeIterator {}
+
+impl<I> Display for ExactlyOneError<I> 
+    where I: Iterator,
+{
+    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+        let additional = self.additional_len();
+        if additional > 0 {
+            write!(f, "got at least 2 elements when exactly one was expected")
+        } else {
+            write!(f, "got zero elements when exactly one was expected")
         }
-        if self.first_two.1.is_some() {
-            additional_len += 1;
+    }
+}
+
+impl<I> Debug for ExactlyOneError<I> 
+    where I: Iterator + Debug,
+          I::Item: Debug,
+{
+    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+        match &self.first_two {
+            Some(Either::Left([first, second])) => {
+                write!(f, "ExactlyOneError[First: {:?}, Second: {:?}, RemainingIter: {:?}]", first, second, self.inner)
+            },
+            Some(Either::Right(second)) => {
+                write!(f, "ExactlyOneError[Second: {:?}, RemainingIter: {:?}]", second, self.inner)
+            }
+            None => {
+                write!(f, "ExactlyOneError[RemainingIter: {:?}]", self.inner)
+            }
         }
-        size_hint::add_scalar(self.inner.size_hint(), additional_len)
     }
 }
 
-impl<I> ExactSizeIterator for ExactlyOneError<I> where I: ExactSizeIterator {}
+#[cfg(feature = "use_std")]
+impl<I> Error for ExactlyOneError<I>  where I: Iterator + Debug, I::Item: Debug, {}
+
+