Enum CoroState 

pub enum CoroState<S, R, T, F>
where
    S: Unpin,
    R: Unpin,
    F: Future<Output = T>,
{
    Pending(PendingCoro<S, R, T, F>, S),
    Complete(T),
}

The intermediate state of a Coro while it is executing

Variants

Pending(PendingCoro<S, R, T, F>, S)

The Coro yielded via yield_value. Call the send method on the inner PendingCoro to send a value back into the coroutine and convert it back to a ReadyCoro which can be resumed.

Complete(T)

The Coro is now complete and has returned a value.

Implementations

impl<S, R, T, F> CoroState<S, R, T, F>

where S: Unpin, R: Unpin, F: Future<Output = T>,

pub fn is_pending(&self) -> bool

Returns true if this is a Pending value.

Example

let mut coro = Coro::from(async |handle: Handle<(), usize>| {
    let n = handle.yield_value(()).await;
    assert_eq!(n, 70);
});

let state = coro.resume();
assert_eq!(state.is_pending(), true);

coro = state.unwrap_pending(|_| 70);

let state = coro.resume();
assert_eq!(state.is_pending(), false);

pub fn is_complete(&self) -> bool

Returns true if this is a Complete value.

Example

let mut coro = Coro::from(async |handle: Handle<(), usize>| {
    let n = handle.yield_value(()).await;
    assert_eq!(n, 70);
});

let state = coro.resume();
assert_eq!(state.is_complete(), false);

coro = state.unwrap_pending(|_| 70);

let state = coro.resume();
assert_eq!(state.is_complete(), true);

pub fn unwrap_pending(self, f: impl Fn(S) -> R) -> ReadyCoro<S, R, T, F>

Assume that this value is Pending and send a response to the underlying Coro using the provided mapping function to unwrap it into a ReadyCoro.

Panics

This will panic if the value was Complete.

Example

let mut coro = Coro::from(async |handle: Handle<(), usize>| {
    let n = handle.yield_value(()).await;
    assert_eq!(n, 70);
});

coro = coro.resume().unwrap_pending(|_| 70);

pub fn unwrap(self) -> T

Assume that this value is Complete and unwrap it to return the inner value.

Panics

This will panic if the value was Pending.

Example

let mut coro = Coro::from(async |handle: Handle<(), ()>| {
    "done"
});

assert_eq!(coro.resume().unwrap(), "done");

Trait Implementations

impl<S, R, T: Debug, F> Debug for CoroState<S, R, T, F>

where S: Unpin + Debug, R: Unpin + Debug, F: Future<Output = T> + Debug,

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

Formats the value using the given formatter.