Trait pushgen::traits::ReverseGenerator

pub trait ReverseGenerator: Generator {
    // Required method
    fn run_back(
        &mut self,
        output: impl FnMut(Self::Output) -> ValueResult
    ) -> GeneratorResult;

    // Provided method
    fn try_advance_back(&mut self, n: NonZeroUsize) -> (usize, GeneratorResult) { ... }
}

A generator able to produce values from in reverse order.

A generator that implements ReverseGenerator can produce values in reverse order.

Both forward and reverse generation work on the same range and do not cross: a generator is complete when the forward and reverse generator meets.

Examples

Basic usage:

use pushgen::{SliceGenerator, GeneratorResult, GeneratorExt};
let numbers = [1, 2, 3, 4, 5, 6];
let mut gen = SliceGenerator::new(&numbers);

assert_eq!(Ok(&1), gen.next());
assert_eq!(Ok(&6), gen.next_back());
assert_eq!(Ok(&5), gen.next_back());
assert_eq!(Ok(&2), gen.next());
assert_eq!(Ok(&3), gen.next());
assert_eq!(Ok(&4), gen.next());
assert_eq!(Err(GeneratorResult::Complete), gen.next());
assert_eq!(Err(GeneratorResult::Complete), gen.next_back());

Required Methods

fn run_back( &mut self, output: impl FnMut(Self::Output) -> ValueResult ) -> GeneratorResult

Run a generator backwards, producing values from the end to the beginning.

Provided Methods

fn try_advance_back(&mut self, n: NonZeroUsize) -> (usize, GeneratorResult)

Tries to advance the generator from the back by n values.

Implementors

impl<'a, Src, T> ReverseGenerator for Cloned<Src>where T: 'a + Clone, Src: Generator<Output = &'a T> + ReverseGenerator,

impl<'a, Src, T> ReverseGenerator for Copied<Src>where T: 'a + Copy, Src: Generator<Output = &'a T> + ReverseGenerator,

impl<'a, T> ReverseGenerator for SliceGenerator<'a, T>

impl<First, Second> ReverseGenerator for Chain<First, Second>where First: ReverseGenerator, Second: ReverseGenerator<Output = First::Output>,

impl<Gen, Func, Out> ReverseGenerator for FilterMap<Gen, Func>where Gen: ReverseGenerator, Func: FnMut(Gen::Output) -> Option<Out>,

impl<Gen, Func, Out> ReverseGenerator for Map<Gen, Func>where Gen: ReverseGenerator, Func: FnMut(Gen::Output) -> Out,

impl<Gen, Pred> ReverseGenerator for Filter<Gen, Pred>where Gen: ReverseGenerator, Pred: FnMut(&Gen::Output) -> bool,

impl<I: DoubleEndedIterator> ReverseGenerator for FromIter<I>

impl<L, R> ReverseGenerator for Either<L, R>where L: ReverseGenerator, R: ReverseGenerator<Output = L::Output>,

impl<Src> ReverseGenerator for Flatten<Src>where Src: ReverseGenerator, Src::Output: IntoGenerator, <Src::Output as IntoGenerator>::IntoGen: ReverseGenerator,

impl<Src> ReverseGenerator for Reverse<Src>where Src: ReverseGenerator,

impl<Src, F> ReverseGenerator for Inspect<Src, F>where Src: ReverseGenerator, F: FnMut(&Src::Output),

impl<T> ReverseGenerator for OptionGen<T>

impl<T, const N: usize> ReverseGenerator for ArrayGenerator<T, N>