Struct Effect

pub struct Effect<'a, A> { /* private fields */ }

An effect monad.

This is essentially just a newtype for a boxed Future that implements Monad, so that you can treat your Futures like they’re Monads with the run! macro and all the category theory you like.

To turn a Future into an Effect monad, use From and Into:

let my_future = async { "Hello Joe!" };
let my_effect = Effect::from(my_future);

Effects can be awaited like they’re futures, because they implement IntoFuture:

assert_eq!(my_effect.await, "Hello Joe!");

You can compose effects using the run! macro:

run! {
    // Lift the value 1 into the Effect monad
    x <= Effect::pure(1);
    // Create an effect from an async block returning the value 2
    y <= Effect::from(async { 2 });
    // Perform a computation in an async block using the previously bound values
    z <= Effect::from(async move { x + y });
    // Compute the result and await it
    yield x + y + z
}.await

Trait Implementations

impl<'a, A> Apply<'a, A> for Effect<'a, A>

where A: 'a,

type Target<T> = Effect<'a, T> where T: 'a

fn apply<B>( self, f: <Self as Apply<'a, A>>::Target<ApplyFn<'a, A, B>>, ) -> <Self as Apply<'a, A>>::Target<B>

where B: 'a,

impl<'a, A> Bind<'a, A> for Effect<'a, A>

where A: 'a,

type Target<T> = Effect<'a, T>

fn bind<B, F>(self, f: F) -> Self::Target<B>

where F: Fn(A) -> Self::Target<B> + 'a,

impl<'a, A> Debug for Effect<'a, A>

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

Formats the value using the given formatter.

impl<'a, A, F> From<F> for Effect<'a, A>

where F: Future<Output = A> + 'a,

fn from(future: F) -> Self

Converts to this type from the input type.

impl<'a, A> Functor<'a, A> for Effect<'a, A>

where A: 'a,

type Target<T> = Effect<'a, T>

fn fmap<B, F>(self, f: F) -> Self::Target<B>

where F: Fn(A) -> B + 'a,

impl<'a, A> IntoFuture for Effect<'a, A>

type Output = A

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = A> + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<'a, A> Pure<A> for Effect<'a, A>

where A: 'a,

fn pure(value: A) -> Self