Struct higher_effect::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

Implementations

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

pub fn run(self) -> A

Run the effect to completion, blocking the current thread.

pub fn ready(value: A) -> Selfwhere
    A: 'a,

Construct an effect that resolves immediately to the given value.

pub fn select<B>(
    eff1: Effect<'a, A>,
    eff2: Effect<'a, B>
) -> Effect<'a, Either<(A, Effect<'a, B>), (B, Effect<'a, A>)>>where
    A: 'a,
    B: 'a,

Runs two effects in parallel, returning the result of whichever finishes first.

pub fn select_all<I>(iter: I) -> Effect<'a, (A, usize, Vec<Effect<'a, A>>)>where
    A: 'a,
    I: IntoIterator<Item = Effect<'a, A>> + 'a,

Runs a list of effects in parallel, returning the result of whichever finishes first.

pub fn join<B>(eff1: Effect<'a, A>, eff2: Effect<'a, B>) -> Effect<'a, (A, B)>where
    A: 'a,
    B: 'a,

Runs two effects in parallel, returning the results of both.

pub fn join3<B, C>(
    eff1: Effect<'a, A>,
    eff2: Effect<'a, B>,
    eff3: Effect<'a, C>
) -> Effect<'a, (A, B, C)>where
    A: 'a,
    B: 'a,
    C: 'a,

Runs three effects in parallel, returning the results of all three.

pub fn join4<B, C, D>(
    eff1: Effect<'a, A>,
    eff2: Effect<'a, B>,
    eff3: Effect<'a, C>,
    eff4: Effect<'a, D>
) -> Effect<'a, (A, B, C, D)>where
    A: 'a,
    B: 'a,
    C: 'a,
    D: 'a,

Runs four effects in parallel, returning the results of all four.

pub fn join_all<I>(iter: I) -> Effect<'a, Vec<A>>where
    I: IntoIterator<Item = Effect<'a, A>> + 'a,

Runs a list of effects in parallel, returning a list of their results when they have all resolved.

Trait Implementations

impl<'a, A> Apply<'a, A> for Effect<'a, A>where
    A: Clone + 'a,

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

Apply an F of functions from A to B to an F of A, producing an F of B.

fn apply_first<B>(self, b: Self::Target<B>) -> Selfwhere
    B: 'a,
    Self: Sized,
    A: Clone,
    Self::Target<B>: Apply<'a, B, Target<ApplyFn<'a, B, A>> = Self::Target<ApplyFn<'a, B, A>>>,

fn apply_second<B>(self, b: Self::Target<B>) -> Self::Target<B>where
    B: 'a + Clone,
    Self: Sized,
    Self::Target<B>: Apply<'a, B, Target<ApplyFn<'a, A, B>> = Self::Target<ApplyFn<'a, A, B>>>,

impl<'a, A> Bind<'a, A> for Effect<'a, A>where
    A: Clone + 'a,

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

Apply the function f to the A or As inside the M<A> to turn it into an M<B>.

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: 'a> Functor<'a, A> for Effect<'a, A>

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

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

Map a functor of A to a functor of B using a function from A to B.

fn fconst<B>(self, b: B) -> Self::Target<B>where
    Self: Sized,
    B: Clone,

Map the functor to the provided constant value.

fn void(self) -> Self::Target<()>where
    Self: Sized,

Map the functor to the unit value ().

fn f_into_iter(self) -> Box<dyn Iterator<Item = A> + 'static, Global>where
    Self: Sized,
    A: 'static,

Turn the functor into an iterator.

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, Global>>

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