Enum std::ops::GeneratorState

#[lang = "generator_state"]
pub enum GeneratorState<Y, R> {
    Yielded(Y),
    Complete(R),
}

The result of a generator resumption.

This enum is returned from the Generator::resume method and indicates the possible return values of a generator. Currently this corresponds to either a suspension point (Yielded) or a termination point (Complete).

Variants

Yielded(Y)

The generator suspended with a value.

This state indicates that a generator has been suspended, and typically corresponds to a yield statement. The value provided in this variant corresponds to the expression passed to yield and allows generators to provide a value each time they yield.

Complete(R)

The generator completed with a return value.

This state indicates that a generator has finished execution with the provided value. Once a generator has returned Complete it is considered a programmer error to call resume again.

Trait Implementations

impl<Y, R> Clone for GeneratorState<Y, R> where
    R: Clone,
    Y: Clone,  [src]

fn clone(&self) -> GeneratorState<Y, R> [src]

fn clone_from(&mut self, source: &Self)

1.0.0

[src]

impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialOrd<R>,
    Y: PartialOrd<Y>,  [src]

fn partial_cmp(&self, __arg_0: &GeneratorState<Y, R>) -> Option<Ordering> [src]

fn lt(&self, __arg_0: &GeneratorState<Y, R>) -> bool [src]

fn le(&self, __arg_0: &GeneratorState<Y, R>) -> bool [src]

fn gt(&self, __arg_0: &GeneratorState<Y, R>) -> bool [src]

fn ge(&self, __arg_0: &GeneratorState<Y, R>) -> bool [src]

impl<Y, R> Eq for GeneratorState<Y, R> where
    R: Eq,
    Y: Eq,  [src]

impl<Y, R> Hash for GeneratorState<Y, R> where
    R: Hash,
    Y: Hash,  [src]

fn hash<__HYR>(&self, __arg_0: &mut __HYR) where
    __HYR: Hasher,  [src]

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

1.3.0

[src]

impl<Y, R> Copy for GeneratorState<Y, R> where
    R: Copy,
    Y: Copy,  [src]

impl<Y, R> Ord for GeneratorState<Y, R> where
    R: Ord,
    Y: Ord,  [src]

fn cmp(&self, __arg_0: &GeneratorState<Y, R>) -> Ordering [src]

fn max(self, other: Self) -> Self

1.21.0

[src]

fn min(self, other: Self) -> Self

1.21.0

[src]

impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where
    R: PartialEq<R>,
    Y: PartialEq<Y>,  [src]

fn eq(&self, __arg_0: &GeneratorState<Y, R>) -> bool [src]

fn ne(&self, __arg_0: &GeneratorState<Y, R>) -> bool [src]

impl<Y, R> Debug for GeneratorState<Y, R> where
    R: Debug,
    Y: Debug,  [src]

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error> [src]