Trait brontes_types::tree::util::zip::SplitIterZip

pub trait SplitIterZip<NewI>: Iterator
where
    NewI: Iterator,
{
    type Out: Iterator;

    // Required method
    fn zip_with_inner(self, other: NewI) -> Self::Out;
}

Required Associated Types

type Out: Iterator

Required Methods

fn zip_with_inner(self, other: NewI) -> Self::Out

Implementors

impl<A, B, C, D, E, F, G, I> SplitIterZip<I> for ZipPadded7<A, B, C, D, E, F, G>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator, G: Iterator,

type Out = ZipPadded8<A, B, C, D, E, F, G, I>

impl<A, B, C, D, E, F, I> SplitIterZip<I> for ZipPadded6<A, B, C, D, E, F>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator,

type Out = ZipPadded7<A, B, C, D, E, F, I>

impl<A, B, C, D, E, I> SplitIterZip<I> for ZipPadded5<A, B, C, D, E>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator,

type Out = ZipPadded6<A, B, C, D, E, I>

impl<A, B, C, D, I> SplitIterZip<I> for ZipPadded4<A, B, C, D>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator,

type Out = ZipPadded5<A, B, C, D, I>

impl<A, B, C, I> SplitIterZip<I> for ZipPadded3<A, B, C>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator,

type Out = ZipPadded4<A, B, C, I>

impl<A, B, I> SplitIterZip<I> for ZipPadded2<A, B>

where I: Iterator, A: Iterator, B: Iterator,

type Out = ZipPadded3<A, B, I>

impl<A, I> SplitIterZip<I> for ZipPadded1<A>

where I: Iterator, A: Iterator,

type Out = ZipPadded2<A, I>

impl<V: NormalizedAction, A, B, C, D, E, F, G, I> SplitIterZip<I> for ZipPaddedTree7<V, A, B, C, D, E, F, G>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator, G: Iterator,

type Out = ZipPaddedTree8<V, A, B, C, D, E, F, G, I>

impl<V: NormalizedAction, A, B, C, D, E, F, I> SplitIterZip<I> for ZipPaddedTree6<V, A, B, C, D, E, F>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator,

type Out = ZipPaddedTree7<V, A, B, C, D, E, F, I>

impl<V: NormalizedAction, A, B, C, D, E, I> SplitIterZip<I> for ZipPaddedTree5<V, A, B, C, D, E>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator,

type Out = ZipPaddedTree6<V, A, B, C, D, E, I>

impl<V: NormalizedAction, A, B, C, D, I> SplitIterZip<I> for ZipPaddedTree4<V, A, B, C, D>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator, D: Iterator,

type Out = ZipPaddedTree5<V, A, B, C, D, I>

impl<V: NormalizedAction, A, B, C, I> SplitIterZip<I> for ZipPaddedTree3<V, A, B, C>

where I: Iterator, A: Iterator, B: Iterator, C: Iterator,

type Out = ZipPaddedTree4<V, A, B, C, I>

impl<V: NormalizedAction, A, B, I> SplitIterZip<I> for ZipPaddedTree2<V, A, B>

where I: Iterator, A: Iterator, B: Iterator,

type Out = ZipPaddedTree3<V, A, B, I>

impl<V: NormalizedAction, A, I> SplitIterZip<I> for ZipPaddedTree1<V, A>

where I: Iterator, A: Iterator,

type Out = ZipPaddedTree2<V, A, I>