Trait simple_generators_util::GeneratorExt

pub trait GeneratorExt<R>: Generator<R> {
    fn map_yield<F, T>(self, func: F) -> MapYield<Self, F>
    where
        F: FnMut(Self::Yield) -> T,
        Self: Sized,
    { ... }
    fn map_return<F, T>(self, func: F) -> MapReturn<Self, F>
    where
        F: FnMut(Self::Return) -> T,
        Self: Sized,
    { ... }
    fn map_resume<F, T>(self, func: F) -> MapResume<Self, F>
    where
        F: FnMut(T) -> R,
        Self: Sized,
    { ... }
    fn resume_unpin(
        &mut self, 
        arg: R
    ) -> GeneratorState<Self::Yield, Self::Return>
    where
        Self: Unpin,
    { ... }
    fn by_ref(&mut self) -> &mut Self { ... }
    fn iterate_over_yields(self) -> SimpleGenIterator<Self>
    where
        Self: Sized + Unpin,
        Self::Return: SupportedReturnValue,
    { ... }
    fn into_raw_iterator(self) -> RawGenIterator<Self>
    where
        Self: Generator<()> + Sized + Unpin,
    { ... }
    fn into_fused_iterator(self) -> FusedGenIterator<Self>
    where
        Self: Generator<()> + Sized + Unpin,
    { ... }
}

This trait is automatically implemented for all generators.

Provided methods

fn map_yield<F, T>(self, func: F) -> MapYield<Self, F> where
    F: FnMut(Self::Yield) -> T,
    Self: Sized, 

Apply provided function to each yielded value.

fn map_return<F, T>(self, func: F) -> MapReturn<Self, F> where
    F: FnMut(Self::Return) -> T,
    Self: Sized, 

Apply provided function to return value.

fn map_resume<F, T>(self, func: F) -> MapResume<Self, F> where
    F: FnMut(T) -> R,
    Self: Sized, 

Apply provided function to resume arguments. For example, if resume arg implements Default, and you want an iterator, you can use the following:

#![feature(generator_trait, generators)]
use core::ops::Generator;
use core::marker::Unpin;
use simple_generators_util::GeneratorExt;
fn sum_of_yields<R: Default, G: Generator<R, Yield=u64, Return=()> + Unpin>(gen: G) -> u64 {
   let gen = gen.map_resume(|()| R::default());
   gen.iterate_over_yields().sum()
}
let generator = || {
    for x in 0.. {
        if x * x * x > 100 {
            return;
        }
        yield x * x;
    }    
};
assert_eq!(sum_of_yields(generator), 30);

fn resume_unpin(&mut self, arg: R) -> GeneratorState<Self::Yield, Self::Return> where
    Self: Unpin, 

Generator::Resume, but without explicit pinning.

fn by_ref(&mut self) -> &mut Self

Utility method to pass a generator by mutable ref.

fn iterate_over_yields(self) -> SimpleGenIterator<Self> where
    Self: Sized + Unpin,
    Self::Return: SupportedReturnValue, 

Converts this generator into iterator over yielded values. Can be used for simple construction of complex iterators.

fn into_raw_iterator(self) -> RawGenIterator<Self> where
    Self: Generator<()> + Sized + Unpin, 

Converts this generator into iterator over GeneratorState.

fn into_fused_iterator(self) -> FusedGenIterator<Self> where
    Self: Generator<()> + Sized + Unpin, 

Convers this iterator into fused iterator. That iterator also supports retrieving return value.

Loading content...

Implementors

impl<R, G: Generator<R>> GeneratorExt<R> for G

Loading content...