Struct Effect 

pub struct Effect<A, E, S> { /* private fields */ }

A description of a program. A is the success value, E is the expected error, and S is the service environment required to run it.

Implementations

impl<A, E, S> Effect<A, E, S>

where A: Send + Sync + 'static, E: Send + Sync + 'static, S: Send + Sync + 'static,

pub fn succeed(value: A) -> Self

where A: Clone,

pub fn fail(error: E) -> Self

where E: Clone,

pub fn die(message: impl Into<String>) -> Self

pub fn from_async<F, Fut>(f: F) -> Self

where F: Fn(Arc<S>, CancellationToken) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<A, Exit<E>>> + Send + 'static,

Build a program from services and a cancellation token. The function runs only when Effect::run is called.

pub fn map<B, F>(&self, f: F) -> Effect<B, E, S>

where B: Send + Sync + 'static, F: Fn(A) -> B + Send + Sync + 'static,

pub fn and_then<B, F>(&self, f: F) -> Effect<B, E, S>

where B: Send + Sync + 'static, F: Fn(A) -> Effect<B, E, S> + Send + Sync + 'static,

pub fn catch_fail<F>(&self, f: F) -> Self

where F: Fn(E) -> Effect<A, E, S> + Send + Sync + 'static,

Handle an expected failure. Defects and interruption pass through.

pub fn retry(&self, schedule: Schedule) -> Self

where E: Clone,

Retry expected failures. Interruption and defects are not retried.

pub fn timeout(&self, duration: Duration) -> Self

pub fn with_span(&self, name: impl Into<String>) -> Self

pub fn zip_par<B>(&self, right: &Effect<B, E, S>) -> Effect<(A, B), E, S>

where B: Send + Sync + 'static,

Run left and right together. The first expected failure or defect cancels the sibling and waits for that sibling to finish.

pub fn race(&self, other: &Self) -> Self

First success or failure wins. The other side is cancelled and awaited.

pub fn bracket<B, F, R>(&self, release: R, body: F) -> Effect<B, E, S>

where A: Clone, B: Send + Sync + 'static, F: Fn(A) -> Effect<B, E, S> + Send + Sync + 'static, R: Fn(A) + Send + Sync + 'static,

Acquire a resource, use it, and release it on success, expected failure, and cancellation. Dropping the running future releases it too.

pub fn provide<S2>(self, services: S) -> Effect<A, E, S2>

where S2: Send + Sync + 'static,

Replace the service environment. The resulting program no longer requires S; the caller supplies a different environment at the edge.

pub async fn run( self, services: Arc<S>, ) -> (Result<A, Exit<E>>, Vec<TraceEvent>)

Trait Implementations

impl<A, E, S> Clone for Effect<A, E, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.