Struct Effect 

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

Implementations

impl<R, E, A> Effect<R, E, A>

where R: Clone + Send + Sync + 'static, E: Send + Sync + 'static, A: Send + Sync + 'static,

pub fn succeed(value: A) -> Self

where A: Send + Sync + Clone,

Creates an effect that succeeds with the given value.

pub fn fail(error: E) -> Self

where E: Send + Sync + Clone,

Creates an effect that fails with the given error.

pub fn sync<F>(f: F) -> Self

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

Creates an effect from a function that returns a value.

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

where F: FnOnce() -> Fut + Send + Sync + 'static + Clone, Fut: Future<Output = A> + Send + 'static, A: Send,

Creates an effect from a future.

pub fn sleep(duration: Duration) -> Self

where A: From<()>,

Creates an effect that sleeps for the specified duration.

pub fn with_metric_increment(self, name: &str, labels: Vec<MetricLabel>) -> Self

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

Records a metric increment when this effect runs.

pub fn with_metric_duration(self, name: &str, labels: Vec<MetricLabel>) -> Self

where A: Send + Sync + 'static + Clone, E: Send + Sync + 'static + Clone, R: 'static + Clone + Send + Sync,

Records duration of this effect in a histogram.

pub fn timed(self, name: &str, labels: Vec<MetricLabel>) -> Self

where A: Send + Sync + 'static + Clone, E: Send + Sync + 'static + Clone, R: 'static + Clone + Send + Sync,

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

where R: Send + Sync, F: FnOnce(EnvRef<R>, Ctx) -> Fut + Send + Sync + 'static + Clone, Fut: Future<Output = A> + Send + 'static, A: Send,

Creates an effect with access to the environment.

pub fn provide(self, env: R) -> Effect<(), E, A>

where R: Clone + Send + Sync + 'static, E: Send + Sync + 'static, A: Send + Sync + 'static,

Provides the environment to the effect, eliminating the dependency R.

pub fn done(exit: Exit<E, A>) -> Self

where E: Send + Sync + Clone, A: Send + Sync + Clone,

Creates an effect from an Exit value.

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

where F: FnOnce(A) -> B + Send + Sync + 'static + Clone, B: Send + Sync + 'static + Clone, R: Clone + Send + Sync + 'static, E: Send + Sync + 'static, A: Send + Sync + 'static,

pub fn map_error<E2, F>(self, f: F) -> Effect<R, E2, A>

where F: Fn(E) -> E2 + Send + Sync + 'static + Clone, R: Send + Sync + 'static, A: Send + Sync + 'static, E: Send + Sync + 'static, E2: Send + Sync + 'static,

pub fn flat_map<B, F>(self, f: F) -> Effect<R, E, B>

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

pub fn delay(self, duration: Duration) -> Effect<R, E, A>

where R: Clone + Send + Sync + 'static, E: Send + Sync + 'static, A: Send + Sync + 'static,

Delays the execution of this effect by the specified duration.

pub fn trace(self, name: &'static str) -> Effect<R, E, A>

where R: Clone + Send + Sync + 'static, E: Send + Sync + 'static, A: Send + Sync + 'static,

Wraps the effect execution in a tracing span with the given name.

pub fn on_interrupt<F, R2, E2, X>(self, cleanup: F) -> Effect<R, E, A>

where F: Fn() -> Effect<R2, E2, X> + Send + Sync + 'static + Clone, R2: From<R> + Send + Sync + 'static + Clone, E2: Send + Sync + 'static, X: Send + Sync + 'static,

Runs a cleanup effect if this effect is interrupted.

pub fn acquire_release<F, R2, E2, X>(self, release: F) -> Effect<R, E, A>

where F: FnOnce(A, ScopeExit) -> Effect<R2, E2, X> + Send + Sync + 'static + Clone, R: Clone + Send + Sync + 'static, R2: From<R> + Send + Sync + 'static + Clone, E: Send + Sync + 'static, A: Send + Sync + Clone + 'static, X: Send + Sync + 'static, E2: Send + Sync + 'static,

Acquires a resource, then registers a finalizer to release it. The release effect is guaranteed to run when the scope closes.

pub fn fork(self) -> Effect<R, E, Fiber<E, A>>

where R: Clone + Send + Sync + 'static, E: Send + Sync + Clone + 'static, A: Send + Sync + Clone + 'static,

Forks the effect into a new fiber.

pub fn zip_par<B>(self, other: Effect<R, E, B>) -> Effect<R, E, (A, B)>

where R: Clone + Send + Sync + 'static, E: Send + Sync + Clone + 'static, A: Send + Sync + Clone + 'static, B: Send + Sync + Clone + 'static,

Runs this effect and another effect in parallel, returning both results. If either effect fails, the other is interrupted.

pub fn race(self, other: Effect<R, E, A>) -> Effect<R, E, A>

where R: Clone + Send + Sync + 'static, E: Send + Sync + Clone + 'static, A: Send + Sync + Clone + 'static,

pub fn collect_all_par<I>(effects: I) -> Effect<R, E, Vec<A>>

where I: IntoIterator<Item = Effect<R, E, A>>, I::IntoIter: Send, R: Clone + Send + Sync + 'static, E: Send + Sync + Clone + 'static, A: Send + Sync + Clone + 'static,

impl<R, E, A> Effect<R, E, A>

where R: Send + Sync + 'static + Clone, E: Send + Sync + 'static + Clone, A: Send + Sync + 'static + Clone,

pub fn retry<Out>(self, policy: Schedule<E, Out>) -> Effect<R, E, A>

where Out: Send + Sync + 'static + Clone,

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.