Trait akka_persistence_rs::effect::EffectExt

pub trait EffectExt<B>: Effect<B>
where
    B: EventSourcedBehavior + Send + Sync + 'static,
{
    // Provided methods
    fn and<R>(self, r: R) -> And<B, Self, R>
       where Self: Sized,
             R: Effect<B> { ... }
    fn and_then<F, R>(self, f: F) -> And<B, Self, Then<B, F, R>>
       where Self: Sized,
             B::State: Send + Sync,
             F: FnOnce(&B, Option<&B::State>, Result) -> R + Send,
             R: Future<Output = Result> { ... }
    fn then_persist_event<F>(
        self,
        f: F
    ) -> And<B, Self, ThenPersistEvent<B, Box<dyn FnOnce(&B, Option<&B::State>, Result) -> Ready<StdResult<Option<B::Event>, Error>> + Send>, Ready<StdResult<Option<B::Event>, Error>>>>
       where Self: Sized,
             B::State: Send + Sync,
             F: FnOnce(Option<&B::State>) -> Option<B::Event> + Send + 'static { ... }
    fn then_reply<F, T>(
        self,
        f: F
    ) -> And<B, Self, ThenReply<B, Box<dyn FnOnce(&B, Option<&B::State>, Result) -> Ready<ReplyResult<T>> + Send>, Ready<ReplyResult<T>>, T>>
       where Self: Sized,
             B::State: Send + Sync,
             F: FnOnce(Option<&B::State>) -> Option<ReplyTo<T>> + Send + 'static,
             T: Send { ... }
    fn boxed(self) -> Box<dyn Effect<B>>
       where Self: Sized + 'static { ... }
}

Combinators for use with effects.

Provided Methods

fn and<R>(self, r: R) -> And<B, Self, R>

where Self: Sized, R: Effect<B>,

Perform the provided effect after this current one.

fn and_then<F, R>(self, f: F) -> And<B, Self, Then<B, F, R>>

where Self: Sized, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result>,

Perform a side effect to run a function asynchronously after this current one. The associated behavior is available so that communication channels, for example, can be accessed by the side-effect. Additionally, the latest state given any previous effect having persisted an event, or else the state at the outset of the effects being applied, is also available.

fn then_persist_event<F>( self, f: F ) -> And<B, Self, ThenPersistEvent<B, Box<dyn FnOnce(&B, Option<&B::State>, Result) -> Ready<StdResult<Option<B::Event>, Error>> + Send>, Ready<StdResult<Option<B::Event>, Error>>>>

where Self: Sized, B::State: Send + Sync, F: FnOnce(Option<&B::State>) -> Option<B::Event> + Send + 'static,

An effect to persist an event. The latest state given any previous effect having persisted an event, or else the state at the outset of the effects being applied, is also available.

Only applied when the previous result succeeded.

fn then_reply<F, T>( self, f: F ) -> And<B, Self, ThenReply<B, Box<dyn FnOnce(&B, Option<&B::State>, Result) -> Ready<ReplyResult<T>> + Send>, Ready<ReplyResult<T>>, T>>

where Self: Sized, B::State: Send + Sync, F: FnOnce(Option<&B::State>) -> Option<ReplyTo<T>> + Send + 'static, T: Send,

An effect to reply an envelope. The latest state given any previous effect having persisted an event, or else the state at the outset of the effects being applied, is also available.

Only applied when the previous result succeeded.

fn boxed(self) -> Box<dyn Effect<B>>

where Self: Sized + 'static,

Box the effect for the purposes of returning it.

Implementors

impl<B> EffectExt<B> for PersistEvent<B>

where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send, B::Event: Send,

impl<B, F, R> EffectExt<B> for Then<B, F, R>

where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result> + Send,

impl<B, F, R> EffectExt<B> for ThenPersistEvent<B, F, R>

where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, B::Event: Send, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = Result<Option<B::Event>, Error>> + Send,

impl<B, F, R, T> EffectExt<B> for ThenReply<B, F, R, T>

where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = ReplyResult<T>> + Send, T: Send,

impl<B, L, R> EffectExt<B> for And<B, L, R>

where B: EventSourcedBehavior + Send + Sync + 'static, B::State: Send, L: Effect<B>, R: Effect<B>,

impl<B, T> EffectExt<B> for Reply<B, T>

where B: EventSourcedBehavior + Send + Sync + 'static, T: Send,