Struct genawaiter::sync::Gen

pub struct Gen<Y, R, F: Future> { /* fields omitted */ }

This is a generator which can be shared between threads.

See the module-level docs for examples.

Methods

impl<Y, R, C> Gen<Y, R, Pin<Box<dyn Future<Output = C> + 'static + Send>>>

pub fn new_boxed<F>(producer: impl FnOnce(Co<Y, R>) -> F) -> Self where
    F: Future<Output = C> + Send + 'static, 

Creates a new generator with a boxed future, so it can be stored in a static.

This works exactly the same as Gen::new with an immediately boxed future.

This method exists solely to help the compiler with type inference. These two lines are equivalent, except that the compiler cannot infer the correct type on the second line:

let _: GenBoxed<i32> = Gen::new_boxed(|co| producer(co));
let _: GenBoxed<i32> = Gen::new(|co| Box::pin(producer(co)));

impl<Y, R, F: Future> Gen<Y, R, F>

pub fn new(producer: impl FnOnce(Co<Y, R>) -> F) -> Self

Creates a new generator from a function.

The function accepts a Co object, and returns a future. Every time the generator is resumed, the future is polled. Each time the future is polled, it should do one of two things:

• Call co.yield_(), and then return Poll::Pending.
• Drop the Co, and then return Poll::Ready.

Typically this exchange will happen in the context of an async fn.

See the module-level docs for examples.

pub fn resume_with(&mut self, arg: R) -> GeneratorState<Y, F::Output>

Resumes execution of the generator.

arg is the resume argument. If the generator was previously paused by awaiting a future returned from co.yield(), that future will complete, and return arg.

If the generator yields a value, Yielded is returned. Otherwise, Completed is returned.

See the module-level docs for examples.

impl<Y, F: Future> Gen<Y, (), F>

pub fn resume(&mut self) -> GeneratorState<Y, F::Output>

Resumes execution of the generator.

If the generator yields a value, Yielded is returned. Otherwise, Completed is returned.

See the module-level docs for examples.

pub fn async_resume(
    &mut self
) -> impl Future<Output = GeneratorState<Y, F::Output>> + '_

Resumes execution of the generator.

If the generator pauses without yielding, Poll::Pending is returned. If the generator yields a value, Poll::Ready(Yielded) is returned. Otherwise, Poll::Ready(Completed) is returned.

See the module-level docs for examples.

Trait Implementations

impl<Y, R, F: Future> Coroutine for Gen<Y, R, F>

type Yield = Y

The type of value this generator yields.

type Resume = R

The type of value this generator accepts as a resume argument.

type Return = F::Output

The type of value this generator returns upon completion.

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

Resumes the execution of this generator.

impl<Y, F: Future<Output = ()>> IntoIterator for Gen<Y, (), F>

type Item = Y

The type of the elements being iterated over.

type IntoIter = IntoIter<Y, F>

Which kind of iterator are we turning this into?

#[must_use] fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.