Enum RustIO 

pub enum RustIO<A, T> {
    Right(A),
    Wrong(T),
    Value(A),
    Empty(),
    Fut(LocalBoxFuture<'static, A>),
}

Data structure to be used as the monad to be implemented as Lift RustIO monad can have the list of possible states.

Variants

Right(A)

Wrong(T)

Value(A)

Empty()

Fut(LocalBoxFuture<'static, A>)

Trait Implementations

impl<A, T> Lift<A, T> for RustIO<A, T>

Implementation of the Monad Lift.

fn of(a: A) -> Self

Pure value to create RustIO monad without side-effects.

fn at_some_point<F>(self, op: F) -> Self

where A: Clone, F: Clone + FnOnce(A) -> Self,

Returns an effect that ignores errors and runs repeatedly until it [at_some_point] succeeds We mark A type as Clone since we need a clone of the value for each iteration in the loop. In case you need a backoff between iterations, or a escape clause, you can use [until] or [while] [at_some_point] operator conditions.

fn at_some_point_while<P, F>(self, predicate: P, op: F) -> Self

where A: Clone, P: Clone + FnOnce() -> bool, F: Clone + FnOnce(A) -> Self,

Retry pattern of a task while a predicate condition is false

fn at_some_point_until<P, F>(self, predicate: P, op: F) -> Self

where A: Clone, P: Clone + FnOnce() -> bool, F: Clone + FnOnce(A) -> Self,

Retry pattern of a task while a predicate condition is true

fn parallel<Task: FnOnce() -> Self, F: FnOnce(Vec<A>) -> Self>( tasks: Vec<Task>, op: F, ) -> Self

Operator to run every task in the Vector asynchronously using async. After we create the list of Futures, we use join_all to run all futures in parallel. Once all of them are finished, we invoke the passed function with [Vector] as input param

fn fork<F>(self, op: F) -> Self

where A: 'static, F: 'static + FnOnce(A) -> A,

It run the execution of the task in another green thread We use type Fut to wrap the LocalBoxFuture which it contains the output of the function execution.

fn join(self) -> Self

Join the LocalBoxFuture.

fn daemon<F: FnOnce(&A)>(self, op: F) -> Self

async consumer function that does not affect the current value of the monad.

fn lift(a: A) -> Self

fn from_func(f: fn() -> A) -> Self

fn from_option_func(f: fn() -> Option<A>) -> Self

fn from_result_func(f: fn() -> Result<A, T>) -> Self

fn from_option(a: Option<A>) -> Self

fn from_result(a: Result<A, T>) -> Self

fn merge<F: FnOnce(A, A) -> Self>(a: Self, b: Self, op: F) -> Self

fn get(self) -> A

fn failed(self) -> T

fn get_or_else(self, default: A) -> A

fn is_ok(&self) -> bool

fn is_failed(&self) -> bool

fn is_empty(&self) -> bool

fn map<F: FnOnce(A) -> A>(self, op: F) -> Self

fn map_error<F: FnOnce(T) -> T>(self, op: F) -> Self

fn flat_map<F: FnOnce(A) -> Self>(self, op: F) -> Self

fn when<P: FnOnce(&A) -> bool, F: FnOnce(A) -> A>( self, predicate: P, op: F, ) -> Self

fn when_rio<P: FnOnce(&A) -> bool, F: FnOnce(A) -> Self>( self, predicate: P, op: F, ) -> Self

fn zip<Z1: FnOnce() -> Self, Z2: FnOnce() -> Self, F: FnOnce(A, A) -> Self>( a: Z1, b: Z2, op: F, ) -> Self

fn filter<F: FnOnce(&A) -> bool>(self, op: F) -> Self

fn fold<F: FnOnce(A) -> A>(self, default: A, op: F) -> Self

fn recover<F: FnOnce() -> A>(self, op: F) -> Self

fn recover_with<F: FnOnce() -> Self>(self, op: F) -> Self

fn delay(self, time: Duration) -> Self

fn peek<F: FnOnce(&A)>(self, op: F) -> Self

fn on_error<F: FnOnce(&T)>(self, op: F) -> Self

fn on_success<F: FnOnce(&A)>(self, op: F) -> Self