# [−][src]Enum std::ops::GeneratorState

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

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.

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]

R: Clone,

Y: Clone,

`fn clone(&self) -> GeneratorState<Y, R>`

[src]

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

1.0.0[src]

`impl<Y, R> Copy for GeneratorState<Y, R> where`

R: Copy,

Y: Copy,

[src]

R: Copy,

Y: Copy,

`impl<Y, R> Debug for GeneratorState<Y, R> where`

R: Debug,

Y: Debug,

[src]

R: Debug,

Y: Debug,

`impl<Y, R> Eq for GeneratorState<Y, R> where`

R: Eq,

Y: Eq,

[src]

R: Eq,

Y: Eq,

`impl<Y, R> Hash for GeneratorState<Y, R> where`

R: Hash,

Y: Hash,

[src]

R: Hash,

Y: Hash,

`fn hash<__H>(&self, state: &mut __H) where`

__H: Hasher,

[src]

__H: Hasher,

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

H: Hasher,

1.3.0[src]

H: Hasher,

`impl<Y, R> Ord for GeneratorState<Y, R> where`

R: Ord,

Y: Ord,

[src]

R: Ord,

Y: Ord,

`fn cmp(&self, other: &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]

`fn clamp(self, min: Self, max: Self) -> Self`

[src]

`impl<Y, R> PartialEq<GeneratorState<Y, R>> for GeneratorState<Y, R> where`

R: PartialEq<R>,

Y: PartialEq<Y>,

[src]

R: PartialEq<R>,

Y: PartialEq<Y>,

`fn eq(&self, other: &GeneratorState<Y, R>) -> bool`

[src]

`fn ne(&self, other: &GeneratorState<Y, R>) -> bool`

[src]

`impl<Y, R> PartialOrd<GeneratorState<Y, R>> for GeneratorState<Y, R> where`

R: PartialOrd<R>,

Y: PartialOrd<Y>,

[src]

R: PartialOrd<R>,

Y: PartialOrd<Y>,

`fn partial_cmp(&self, other: &GeneratorState<Y, R>) -> Option<Ordering>`

[src]

`fn lt(&self, other: &GeneratorState<Y, R>) -> bool`

[src]

`fn le(&self, other: &GeneratorState<Y, R>) -> bool`

[src]

`fn gt(&self, other: &GeneratorState<Y, R>) -> bool`

[src]

`fn ge(&self, other: &GeneratorState<Y, R>) -> bool`

[src]

`impl<Y, R> StructuralEq for GeneratorState<Y, R>`

[src]

`impl<Y, R> StructuralPartialEq for GeneratorState<Y, R>`

[src]

## Auto Trait Implementations

`impl<Y, R> RefUnwindSafe for GeneratorState<Y, R> where`

R: RefUnwindSafe,

Y: RefUnwindSafe,

R: RefUnwindSafe,

Y: RefUnwindSafe,

`impl<Y, R> Send for GeneratorState<Y, R> where`

R: Send,

Y: Send,

R: Send,

Y: Send,

`impl<Y, R> Sync for GeneratorState<Y, R> where`

R: Sync,

Y: Sync,

R: Sync,

Y: Sync,

`impl<Y, R> Unpin for GeneratorState<Y, R> where`

R: Unpin,

Y: Unpin,

R: Unpin,

Y: Unpin,

`impl<Y, R> UnwindSafe for GeneratorState<Y, R> where`

R: UnwindSafe,

Y: UnwindSafe,

R: UnwindSafe,

Y: UnwindSafe,

## Blanket Implementations

`impl<T> Any for T where`

T: 'static + ?Sized,

[src]

T: 'static + ?Sized,

`impl<T> Borrow<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

`impl<T> BorrowMut<T> for T where`

T: ?Sized,

[src]

T: ?Sized,

#### ⓘImportant traits for &'_ mut F`fn borrow_mut(&mut self) -> &mut T`

[src]

`impl<T> From<T> for T`

[src]

`impl<T, U> Into<U> for T where`

U: From<T>,

[src]

U: From<T>,

`impl<T> ToOwned for T where`

T: Clone,

[src]

T: Clone,

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`

[src]

`fn clone_into(&self, target: &mut T)`

[src]

`impl<T, U> TryFrom<U> for T where`

U: Into<T>,

[src]

U: Into<T>,

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

[src]

`impl<T, U> TryInto<U> for T where`

U: TryFrom<T>,

[src]

U: TryFrom<T>,