Enum higher::io::IO

pub enum IO<'a, A, E> {
    Future(LocalBoxFuture<'a, Result<A, E>>),
    Error(E),
}

An IO monad.

This wraps a Future similarly to the Effect monad, but the wrapped effect must return a Result. Just as with Result’s Bind implementation, this also short circuits a chain of computations if a step produces an error, resolving immediately to that error.

You can construct an IO monad from a Future which returns a Result:

let my_io_monad = IO::<&str, &str>::from(async { Ok("Hello Joe!") });

You can .await an IO monad and get a Result back:

assert_eq!(my_io_monad.await, Ok("Hello Joe!"));

You can run your IO monads on a thread local executor using the run_io function. Naturally, we also provide a version of Haskell’s putStrLn so that we can implement the canonical hello world in monadic Rust:

run_io(putstrln("Hello Simon!"));

Because IO implements Bind, you can chain async IO operations together using the run! macro:

run_io(run! {
    putstrln("I have the power");
    putstrln("of");
    putstrln("HASKELL")
});

Variants

Future(LocalBoxFuture<'a, Result<A, E>>)

Error(E)

Implementations

impl<'a, A, E> IO<'a, A, E>

pub fn from_error(error: E) -> Self

pub fn map<B, F>(self, f: F) -> IO<'a, B, E>where
    A: 'a,
    E: 'a,
    F: FnOnce(A) -> B + 'a,

pub fn map_error<B, F>(self, f: F) -> IO<'a, A, B>where
    A: 'a,
    E: 'a,
    F: FnOnce(E) -> B + 'a,

pub fn is_err(&self) -> bool

Trait Implementations

impl<'a, A: 'a, E: 'a> Apply<'a, A> for IO<'a, A, E>

type Target<T>
where
    T: 'a = IO<'a, T, E>

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: 'a, E: 'a> Bind<'a, A> for IO<'a, A, E>

type Target<T> = IO<'a, T, E>

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

impl<'a, A, E> Debug for IO<'a, A, E>

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

Formats the value using the given formatter.

impl<'a, A, E, F> From<F> for IO<'a, A, E>where
    F: Future<Output = Result<A, E>> + 'a,

fn from(future: F) -> Self

Converts to this type from the input type.

impl<'a, A: 'a, E: 'a> Functor<'a, A> for IO<'a, A, E>

type Target<T> = IO<'a, T, E>

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

impl<'a, A, E: 'a> IntoFuture for IO<'a, A, E>

type Output = Result<A, E>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = Result<A, E>> + '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: 'a, E> Pure<A> for IO<'a, A, E>

fn pure(value: A) -> Self