Enum eff::next_event::NextEvent

pub enum NextEvent<C: Effectful> {
    Computation(C),
    Event(Event<C::Output, C::Effect>),
    Gone,
}

A combinator created by next_event.

This struct polls the given computation until the first event occurs. It's valid to poll again after this computation completes.

Variants

Computation(C)

the computation has not generated an event yet

Event(Event<C::Output, C::Effect>)

An event occured

Gone

The event has been taken by take_event

Methods

impl<C: Effectful> NextEvent<C>

pub fn occured(&self) -> bool

Checks if the underlying computation generated an event

pub fn take_event(self: Pin<&mut Self>) -> Option<Event<C::Output, C::Effect>>

Take the event if occured

Trait Implementations

impl<C: Effectful> Effectful for NextEvent<C>

type Output = ()

The type of the final result

type Effect = !

The type of the effects this computation will produce

fn poll(self: Pin<&mut Self>, cx: &Context) -> Poll<Self::Output, Self::Effect>

Resume the computation to a final value, registering the current task for wakeup if a handler starts handling an effect performed by the task

fn handle<H, HC, Effect, I>(self, handler: H) -> Handled<Self, H, HC, Effect, I> where
    Self: Sized,
    HC: Effectful,
    H: FnMut(Event<Self::Output, Effect>) -> HC,
    Self::Effect: Subset<Effect, I>, 

Takes a value handler and an effect handler and creates an effectful computation with the effects handled

fn embed<Target, Indices>(self) -> EmbedEffect<Self, Target, Indices> where
    Self: Sized, 

Creates an effectful computation whose effect is a superset of that of this one

fn left<R>(self) -> Either<Self, R> where
    Self: Sized, 

Combine this and the other computation with the same signature

fn right<L>(self) -> Either<L, Self> where
    Self: Sized, 

Combine this and the other computation with the same signature

fn boxed<'a>(
    self
) -> Pin<Box<dyn Effectful<Output = Self::Output, Effect = Self::Effect> + 'a>> where
    Self: Sized + 'a, 

Create a boxed computation

fn output<T>(self) -> Self where
    Self: Effectful<Output = T> + Sized, 

fn effect<E>(self) -> Self where
    Self: Effectful<Effect = E> + Sized, 

Important traits for IntoFuture<C>

impl<C> Future for IntoFuture<C> where
    C: Effectful<Effect = !>,  type Output = C::Output;

fn into_future(self) -> IntoFuture<Self> where
    Self: Effectful<Effect = !> + Sized, 

fn block_on(self) -> Self::Output where
    Self: Sized + Effectful<Effect = !>, 

Run the computation to completion on the current thread

fn next_event(self) -> NextEvent<Self> where
    Self: Sized, 

Create a computation which polls this until the first event occures.