Trait `MultiUnzip`

pub trait MultiUnzip<FromI>: Iterator

An iterator that can be unzipped into multiple collections.

See .multiunzip() for more information.

Required Methods

fn multiunzip(self) -> FromI: Unzip this iterator into multiple collections.

Implementors

impl<IT> MultiUnzip<()> for Batching<I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Chunk<'a, I> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for ExactlyOneError where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Group<'a, K, I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Interleave<I, J> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for InterleaveShortest<I, J> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for IntersperseWith<I, ElemF> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Iterate<St, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for KMergeBy<I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for MergeBy<I, J, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for MultiPeek where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for PadUsing<I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for PeekNth where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for ProcessResults<'a, I, E> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for PutBack where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for PutBackN where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for RcIter where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for RepeatN<A> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for TakeWhileInclusive<I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Tee where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for TupleBuffer<T> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Unfold<St, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Unique<I, S> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for UniqueBy<I, V, F, S> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Update<I, F> where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for WhileSome where IT: Iterator<Item = ()>,
impl<IT> MultiUnzip<()> for Zip<T> where IT: Iterator<Item = ()>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Batching<I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Chunk<'a, I> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for ExactlyOneError where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Group<'a, K, I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Interleave<I, J> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Iterate<St, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for KMergeBy<I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for MergeBy<I, J, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for MultiPeek where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for PadUsing<I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for PeekNth where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for PutBack where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for PutBackN where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for RcIter where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for RepeatN<A> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Tee where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for TupleBuffer<T> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for TupleCombinations<I, T> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for TupleWindows<I, T> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Tuples<I, T> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Unfold<St, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Unique<I, S> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Update<I, F> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for WhileSome where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA> MultiUnzip<(FromA,)> for Zip<T> where IT: Iterator<Item = (A,)>, FromA: Default + Extend<A>,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Batching<I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Chunk<'a, I> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ExactlyOneError where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Groups<'a, K, I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Interleave<I, J> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Iterate<St, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for MultiPeek where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for PadUsing<I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for PeekNth where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Product<I, J> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for PutBack where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for PutBackN where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for RcIter where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for RepeatN<A> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Tee where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for TupleBuffer<T> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Tuples<I, T> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Unfold<St, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Unique<I, S> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Update<I, F> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for WhileSome where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for WithPosition where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for Zip<T> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for ZipEq<I, J> where IT: Iterator<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Batching<I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ExactlyOneError where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for MultiPeek where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for PeekNth where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for PutBack where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for PutBackN where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for RcIter where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for RepeatN<A> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Tee where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Unique<I, S> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Update<I, F> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for WhileSome where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for Zip<T> where IT: Iterator<Item = (A, B, C)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for MultiPeek where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for PeekNth where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for PutBack where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for PutBackN where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for RcIter where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Tee where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for WhileSome where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for Zip<T> where IT: Iterator<Item = (A, B, C, D)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for PutBack where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for RcIter where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Tee where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F, G)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Batching<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Chunk<'a, I> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for CircularTupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ExactlyOneError where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Group<'a, K, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Interleave<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for InterleaveShortest<I, J> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IntersperseWith<I, ElemF> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Iterate<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for KMergeBy<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for MergeBy<I, J, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for MultiPeek where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for PadUsing<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for PeekNth where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for PeekingTakeWhile<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for ProcessResults<'a, I, E> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for PutBack where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for PutBackN where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for RcIter where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for RepeatN<A> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for TakeWhileInclusive<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for TakeWhileRef<'a, I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Tee where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for TupleBuffer<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for TupleCombinations<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for TupleWindows<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Tuples<I, T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Unfold<St, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Unique<I, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for UniqueBy<I, V, F, S> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Update<I, F> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for WhileSome where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for Zip<T> where IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, FromA: Default + Extend<A>, FromB: Default + Extend, FromC: Default + Extend<C>, FromD: Default + Extend<D>, FromE: Default + Extend<E>, FromF: Default + Extend<F>, FromG: Default + Extend<G>, FromH: Default + Extend<H>, FromI: Default + Extend, FromJ: Default + Extend<J>, FromK: Default + Extend<K>, FromL: Default + Extend<L>,
impl<IT: Iterator<Item = ()>> MultiUnzip<()> for IT
impl<IT: Iterator<Item = (A, B)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend> MultiUnzip<(FromA, FromB)> for IT
impl<IT: Iterator<Item = (A, B, C)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>> MultiUnzip<(FromA, FromB, FromC)> for IT
impl<IT: Iterator<Item = (A, B, C, D)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F, G)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>, G, FromG: Default + Extend<G>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F, G, H)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>, G, FromG: Default + Extend<G>, H, FromH: Default + Extend<H>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>, G, FromG: Default + Extend<G>, H, FromH: Default + Extend<H>, I, FromI: Default + Extend> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>, G, FromG: Default + Extend<G>, H, FromH: Default + Extend<H>, I, FromI: Default + Extend, J, FromJ: Default + Extend<J>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>, G, FromG: Default + Extend<G>, H, FromH: Default + Extend<H>, I, FromI: Default + Extend, J, FromJ: Default + Extend<J>, K, FromK: Default + Extend<K>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
impl<IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>, A, FromA: Default + Extend<A>, B, FromB: Default + Extend, C, FromC: Default + Extend<C>, D, FromD: Default + Extend<D>, E, FromE: Default + Extend<E>, F, FromF: Default + Extend<F>, G, FromG: Default + Extend<G>, H, FromH: Default + Extend<H>, I, FromI: Default + Extend, J, FromJ: Default + Extend<J>, K, FromK: Default + Extend<K>, L, FromL: Default + Extend<L>> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
impl<IT: Iterator<Item = (A,)>, A, FromA: Default + Extend<A>> MultiUnzip<(FromA,)> for IT