vendor/itertools-0.7.8/src/ziptuple.rs

   1 use super::size_hint;
   2
   3 /// See [`multizip`](../fn.multizip.html) for more information.
   4 #[derive(Clone, Debug)]
   5 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
   6 pub struct Zip<T> {
   7     t: T,
   8 }
   9
  10 /// An iterator that generalizes *.zip()* and allows running multiple iterators in lockstep.
  11 ///
  12 /// The iterator `Zip<(I, J, ..., M)>` is formed from a tuple of iterators (or values that
  13 /// implement `IntoIterator`) and yields elements
  14 /// until any of the subiterators yields `None`.
  15 ///
  16 /// The iterator element type is a tuple like like `(A, B, ..., E)` where `A` to `E` are the
  17 /// element types of the subiterator.
  18 ///
  19 /// **Note:** The result of this macro is a value of a named type (`Zip<(I, J,
  20 /// ..)>` of each component iterator `I, J, ...`) if each component iterator is
  21 /// nameable.
  22 ///
  23 /// Prefer [`izip!()`] over `multizip` for the performance benefits of using the
  24 /// standard library `.zip()`. Prefer `multizip` if a nameable type is needed.
  25 ///
  26 /// [`izip!()`]: macro.izip.html
  27 ///
  28 /// ```
  29 /// use itertools::multizip;
  30 ///
  31 /// // iterate over three sequences side-by-side
  32 /// let mut results = [0, 0, 0, 0];
  33 /// let inputs = [3, 7, 9, 6];
  34 ///
  35 /// for (r, index, input) in multizip((&mut results, 0..10, &inputs)) {
  36 ///     *r = index * 10 + input;
  37 /// }
  38 ///
  39 /// assert_eq!(results, [0 + 3, 10 + 7, 29, 36]);
  40 /// ```
  41 pub fn multizip<T, U>(t: U) -> Zip<T>
  42     where Zip<T>: From<U>,
  43           Zip<T>: Iterator,
  44 {
  45     Zip::from(t)
  46 }
  47
  48 macro_rules! impl_zip_iter {
  49     ($($B:ident),*) => (
  50         #[allow(non_snake_case)]
  51         impl<$($B: IntoIterator),*> From<($($B,)*)> for Zip<($($B::IntoIter,)*)> {
  52             fn from(t: ($($B,)*)) -> Self {
  53                 let ($($B,)*) = t;
  54                 Zip { t: ($($B.into_iter(),)*) }
  55             }
  56         }
  57
  58         #[allow(non_snake_case)]
  59         #[allow(unused_assignments)]
  60         impl<$($B),*> Iterator for Zip<($($B,)*)>
  61             where
  62             $(
  63                 $B: Iterator,
  64             )*
  65         {
  66             type Item = ($($B::Item,)*);
  67
  68             fn next(&mut self) -> Option<Self::Item>
  69             {
  70                 let ($(ref mut $B,)*) = self.t;
  71
  72                 // NOTE: Just like iter::Zip, we check the iterators
  73                 // for None in order. We may finish unevenly (some
  74                 // iterators gave n + 1 elements, some only n).
  75                 $(
  76                     let $B = match $B.next() {
  77                         None => return None,
  78                         Some(elt) => elt
  79                     };
  80                 )*
  81                 Some(($($B,)*))
  82             }
  83
  84             fn size_hint(&self) -> (usize, Option<usize>)
  85             {
  86                 let sh = (::std::usize::MAX, None);
  87                 let ($(ref $B,)*) = self.t;
  88                 $(
  89                     let sh = size_hint::min($B.size_hint(), sh);
  90                 )*
  91                 sh
  92             }
  93         }
  94
  95         #[allow(non_snake_case)]
  96         impl<$($B),*> ExactSizeIterator for Zip<($($B,)*)> where
  97             $(
  98                 $B: ExactSizeIterator,
  99             )*
 100         { }
 101     );
 102 }
 103
 104 impl_zip_iter!(A);
 105 impl_zip_iter!(A, B);
 106 impl_zip_iter!(A, B, C);
 107 impl_zip_iter!(A, B, C, D);
 108 impl_zip_iter!(A, B, C, D, E);
 109 impl_zip_iter!(A, B, C, D, E, F);
 110 impl_zip_iter!(A, B, C, D, E, F, G);
 111 impl_zip_iter!(A, B, C, D, E, F, G, H);