Struct Continuation 

pub struct Continuation {
    pub yielder: *const Yielder<ContinuationInput, ContinuationOutput>,
    /* private fields */
}

A continuation is a green thread that can be resumed and yielded at will. We use it to execute a “thread” from within a Future.

For efficiency, we reuse continuations. The continuation can be provided a new function to run via initialize. A continuation is only reusable if the previous function it was executing completed.

Fields

yielder: *const Yielder<ContinuationInput, ContinuationOutput>

Implementations

impl Continuation

pub fn new(stack_size: usize) -> Self

pub fn initialize(&mut self, fun: Box<dyn FnOnce()>)

Provide a new function for the continuation to execute. The continuation must be in reusable state.

pub fn resume(&mut self) -> bool

Resume the continuation, and returns true if the function it was executing has finished.

pub fn cancel(&mut self) -> bool

Resume the continuation to cancel its function, and return true if the function has finished, like resume. This is how execution teardown drops a task that is unfinished at the end of an execution, on the task’s own stack (see ExecutionState::tear_down). A function that never ran is dropped. A function suspended between polls of a future (see switch_between_polls) drops the future and returns. Only these two are cancelled: any other suspended function is in the middle of user code, which only unwinding its stack can stop.

Trait Implementations

impl Debug for Continuation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Continuation

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.