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 and_then_emit_event<F, R>(
        self,
        f: F
    ) -> And<B, Self, ThenEmitEvent<B, F, R>>
       where Self: Sized,
             B::State: Send + Sync,
             F: FnOnce(&B, Option<&B::State>, Result) -> R + Send,
             R: Future<Output = StdResult<Option<B::Event>, Error>> + Send { ... }
    fn and_then_emit_deletion_event<F, R>(
        self,
        f: F
    ) -> And<B, Self, ThenEmitEvent<B, F, R>>
       where Self: Sized,
             B::State: Send + Sync,
             F: FnOnce(&B, Option<&B::State>, Result) -> R + Send,
             R: Future<Output = StdResult<Option<B::Event>, Error>> + Send { ... }
    fn and_then_reply<F, R, T>(
        self,
        f: F
    ) -> And<B, Self, ThenReply<B, F, R, T>>
       where Self: Sized,
             B::State: Send + Sync,
             F: FnOnce(&B, Option<&B::State>, Result) -> R + Send,
             R: Future<Output = StdResult<Option<(Sender<T>, T)>, Error>> + Send,
             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 emitted an event, or else the state at the outset of the effects being applied, is also available.

fn and_then_emit_event<F, R>(self, f: F) -> And<B, Self, ThenEmitEvent<B, F, R>>where Self: Sized, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = StdResult<Option<B::Event>, Error>> + Send,

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

fn and_then_emit_deletion_event<F, R>( self, f: F ) -> And<B, Self, ThenEmitEvent<B, F, R>>where Self: Sized, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = StdResult<Option<B::Event>, Error>> + Send,

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

fn and_then_reply<F, R, T>(self, f: F) -> And<B, Self, ThenReply<B, F, R, T>>where Self: Sized, B::State: Send + Sync, F: FnOnce(&B, Option<&B::State>, Result) -> R + Send, R: Future<Output = StdResult<Option<(Sender<T>, T)>, Error>> + Send, T: Send,

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

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 EmitEvent<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 ThenEmitEvent<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 = Result<Option<(Sender<T>, T)>, Error>> + 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,