Trait Generator 

pub trait Generator<R = ()> {
    type Yield;
    type Return;

    // Required method
    fn resume(
        self: Pin<&mut Self>,
        value: R,
    ) -> GeneratorState<Self::Yield, Self::Return>;
}

Required Associated Types

type Yield

type Return

Required Methods

fn resume( self: Pin<&mut Self>, value: R, ) -> GeneratorState<Self::Yield, Self::Return>

Implementations on Foreign Types

impl<R, G> Generator<R> for &mut G

where G: Generator<R> + ?Sized + Unpin,

type Return = <G as Generator<R>>::Return

type Yield = <G as Generator<R>>::Yield

fn resume( self: Pin<&mut Self>, value: R, ) -> GeneratorState<Self::Yield, Self::Return>

impl<R, G> Generator<R> for Box<G>

where G: Generator<R> + ?Sized + Unpin,

Available on crate feature std only.

type Return = <G as Generator<R>>::Return

type Yield = <G as Generator<R>>::Yield

fn resume( self: Pin<&mut Self>, value: R, ) -> GeneratorState<Self::Yield, Self::Return>

impl<R, P> Generator<R> for Pin<P>

where P: DerefMut<Target: Generator<R>>,

type Return = <<P as Deref>::Target as Generator<R>>::Return

type Yield = <<P as Deref>::Target as Generator<R>>::Yield

fn resume( self: Pin<&mut Self>, value: R, ) -> GeneratorState<Self::Yield, Self::Return>

Implementors

impl<A, B, R> Generator<R> for Compose<A, B>

where A: Generator<R>, B: Generator<A::Yield>,

type Return = Either<<A as Generator<R>>::Return, <B as Generator<<A as Generator<R>>::Yield>>::Return>

type Yield = <B as Generator<<A as Generator<R>>::Yield>>::Yield

impl<F, R, C, Y> Generator<R> for CompleteWith<F, Y>

where F: FnOnce(R) -> C,

type Return = C

type Yield = Y

impl<F, R, Y> Generator<R> for OnceWith<F>

where F: FnOnce(R) -> Y,

type Return = ()

type Yield = Y

impl<G1, F, G2, R> Generator<R> for AndThen<G1, F, G2>

where G1: Generator<R>, F: FnOnce(G1::Return) -> G2, G2: Generator<R, Yield = G1::Yield>,

type Yield = <G1 as Generator<R>>::Yield

type Return = <G2 as Generator<R>>::Return

impl<G, F, R, U> Generator<R> for MapComplete<G, F>

where G: Generator<R>, F: FnOnce(G::Return) -> U,

type Yield = <G as Generator<R>>::Yield

type Return = U

impl<G, F, R, U> Generator<R> for MapYield<G, F>

where G: Generator<R>, F: FnMut(G::Yield) -> U,

type Yield = U

type Return = <G as Generator<R>>::Return

impl<R1, R2, G, F> Generator<R1> for Receiving<G, F>

where F: FnMut(R1) -> R2, G: Generator<R2>,

type Yield = <G as Generator<R2>>::Yield

type Return = <G as Generator<R2>>::Return

impl<R, G, C> Generator<R> for Flatten<G, C>

where G: Generator<R, Yield = C>, C: Generator<R, Return = ()>,

type Yield = <C as Generator<R>>::Yield

type Return = <G as Generator<R>>::Return

impl<Y> Generator for Once<Y>

type Return = ()

type Yield = Y