Trait BreadthFirstZip 

pub trait BreadthFirstZip<'item> {
    type Nested: BreadthFirst<'item>;

    // Required methods
    fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>;
    fn unflatten(self) -> Self::Nested;
}

Zip a tuple into a lazy breadth-first traversal of each possible combination with a monotonically increasing sum of indices.

Required Associated Types

type Nested: BreadthFirst<'item>

Rearrangement of input into a nested tuple.

Required Methods

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

Lazy breadth-first exhaustive zip that guarantees a monotonically increasing sum of indices.

fn unflatten(self) -> Self::Nested

Unflatten a tuple like (A, B, C) to BreadthFirstZipped<A, BreadthFirstZipped<B, BreadthFirstZipped<C, BaseCase>>>.

Errors

If any iterator is empty.

Implementations on Foreign Types

impl<'item> BreadthFirstZip<'item> for ()

type Nested = BaseCase

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator> BreadthFirstZip<'item> for (A,)

where A::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BaseCase>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator> BreadthFirstZip<'item> for (A, B)

where A::Item: 'item, B::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BaseCase>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator, C: Iterator> BreadthFirstZip<'item> for (A, B, C)

where A::Item: 'item, B::Item: 'item, C::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BreadthFirstZipped<'item, C, BaseCase>>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator, C: Iterator, D: Iterator> BreadthFirstZip<'item> for (A, B, C, D)

where A::Item: 'item, B::Item: 'item, C::Item: 'item, D::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BreadthFirstZipped<'item, C, BreadthFirstZipped<'item, D, BaseCase>>>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator> BreadthFirstZip<'item> for (A, B, C, D, E)

where A::Item: 'item, B::Item: 'item, C::Item: 'item, D::Item: 'item, E::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BreadthFirstZipped<'item, C, BreadthFirstZipped<'item, D, BreadthFirstZipped<'item, E, BaseCase>>>>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator> BreadthFirstZip<'item> for (A, B, C, D, E, F)

where A::Item: 'item, B::Item: 'item, C::Item: 'item, D::Item: 'item, E::Item: 'item, F::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BreadthFirstZipped<'item, C, BreadthFirstZipped<'item, D, BreadthFirstZipped<'item, E, BreadthFirstZipped<'item, F, BaseCase>>>>>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator, G: Iterator> BreadthFirstZip<'item> for (A, B, C, D, E, F, G)

where A::Item: 'item, B::Item: 'item, C::Item: 'item, D::Item: 'item, E::Item: 'item, F::Item: 'item, G::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BreadthFirstZipped<'item, C, BreadthFirstZipped<'item, D, BreadthFirstZipped<'item, E, BreadthFirstZipped<'item, F, BreadthFirstZipped<'item, G, BaseCase>>>>>>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

impl<'item, A: Iterator, B: Iterator, C: Iterator, D: Iterator, E: Iterator, F: Iterator, G: Iterator, H: Iterator> BreadthFirstZip<'item> for (A, B, C, D, E, F, G, H)

where A::Item: 'item, B::Item: 'item, C::Item: 'item, D::Item: 'item, E::Item: 'item, F::Item: 'item, G::Item: 'item, H::Item: 'item,

type Nested = BreadthFirstZipped<'item, A, BreadthFirstZipped<'item, B, BreadthFirstZipped<'item, C, BreadthFirstZipped<'item, D, BreadthFirstZipped<'item, E, BreadthFirstZipped<'item, F, BreadthFirstZipped<'item, G, BreadthFirstZipped<'item, H, BaseCase>>>>>>>>

fn breadth_first(self) -> BreadthFirstManager<'item, Self::Nested>

fn unflatten(self) -> Self::Nested

Implementors