pub fn multizip<T, U>(t: U) -> Zip<T>ⓘNotable traits for Zip<(A,)>impl<A> Iterator for Zip<(A,)> where
A: Iterator, type Item = (A::Item,);impl<A, B> Iterator for Zip<(A, B)> where
A: Iterator,
B: Iterator, type Item = (A::Item, B::Item);impl<A, B, C> Iterator for Zip<(A, B, C)> where
A: Iterator,
B: Iterator,
C: Iterator, type Item = (A::Item, B::Item, C::Item);impl<A, B, C, D> Iterator for Zip<(A, B, C, D)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item);impl<A, B, C, D, E> Iterator for Zip<(A, B, C, D, E)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item);impl<A, B, C, D, E, F> Iterator for Zip<(A, B, C, D, E, F)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item);impl<A, B, C, D, E, F, G> Iterator for Zip<(A, B, C, D, E, F, G)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator,
G: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item);impl<A, B, C, D, E, F, G, H> Iterator for Zip<(A, B, C, D, E, F, G, H)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator,
G: Iterator,
H: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item);impl<A, B, C, D, E, F, G, H, I> Iterator for Zip<(A, B, C, D, E, F, G, H, I)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator,
G: Iterator,
H: Iterator,
I: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item);impl<A, B, C, D, E, F, G, H, I, J> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator,
G: Iterator,
H: Iterator,
I: Iterator,
J: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item);impl<A, B, C, D, E, F, G, H, I, J, K> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator,
G: Iterator,
H: Iterator,
I: Iterator,
J: Iterator,
K: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item);impl<A, B, C, D, E, F, G, H, I, J, K, L> Iterator for Zip<(A, B, C, D, E, F, G, H, I, J, K, L)> where
A: Iterator,
B: Iterator,
C: Iterator,
D: Iterator,
E: Iterator,
F: Iterator,
G: Iterator,
H: Iterator,
I: Iterator,
J: Iterator,
K: Iterator,
L: Iterator, type Item = (A::Item, B::Item, C::Item, D::Item, E::Item, F::Item, G::Item, H::Item, I::Item, J::Item, K::Item, L::Item); where
Zip<T>: From<U>,
Zip<T>: Iterator, Expand description
An iterator that generalizes .zip() and allows running multiple iterators in lockstep.
The iterator Zip<(I, J, ..., M)> is formed from a tuple of iterators (or values that
implement IntoIterator) and yields elements
until any of the subiterators yields None.
The iterator element type is a tuple like like (A, B, ..., E) where A to E are the
element types of the subiterator.
Note: The result of this macro is a value of a named type (Zip<(I, J, ..)> of each component iterator I, J, ...) if each component iterator is
nameable.
Prefer izip!() over multizip for the performance benefits of using the
standard library .zip(). Prefer multizip if a nameable type is needed.
use itertools::multizip;
// iterate over three sequences side-by-side
let mut results = [0, 0, 0, 0];
let inputs = [3, 7, 9, 6];
for (r, index, input) in multizip((&mut results, 0..10, &inputs)) {
*r = index * 10 + input;
}
assert_eq!(results, [0 + 3, 10 + 7, 29, 36]);