Struct Periodic 

pub struct Periodic<B: Behavior> { /* private fields */ }

Infallible fold invoked for each accepted periodic generation.

fn fallible(_: &mut App) -> behavior::BehaviorActed<App> { Ok(behavior::Actions::cont()) }
let _ = behavior_actors::Periodic::new(App, behavior_actors::TimerId(1), std::time::Duration::from_secs(1), fallible);

Repeatedly notify a wrapped behavior at a relative interval.

Initialization preserves inner effects and appends generation zero. Each matching timer event is consumed once, folds on_elapsed, and—only when that fold continues—appends the next generation. Stale, duplicate, and wrong-ID observations are inert unless the inner protocol accepts them. Termination emits no replacement. Generation exhaustion leaves the timer retired while preserving the inner continuation. These are Bombay policies; clock access and sleeping remain bombay-timers capabilities. Reactions are infallible because they receive mutable access to the wrapped behavior; ordinary delegated transitions retain the wrapped error type.

Implementations

impl<B: Behavior> Periodic<B>

pub fn new( inner: B, id: TimerId, every: Duration, on_elapsed: TimedReaction<B>, ) -> Self

Wrap inner with a relative periodic timer and pure reaction.

Accepted timer generations are rearmed only after a continuing reaction. Clock access and scheduling remain interpreter capabilities.

Trait Implementations

impl<B, A, Ph, Sends, Br> Behavior for Periodic<B>

where A: Address, Sends: SendEffects + SendsFor<B::Event>, Br: BirthMode, B: Behavior<Ph = Ph, Sends = Sends, Birth = Br>, B::Protocol: Protocol<Addr = A>,

type Protocol = <B as Behavior>::Protocol

Stable public communication identity owned by this actor template.

type Event = EventLayer<TimerElapsed, <B as Behavior>::Event>

type Sends = SendLayer<InterpreterRequests<ScheduleAfter>, Sends>

type Ph = Ph

type Error = <B as Behavior>::Error

type Birth = Br

fn init(&mut self, _: InitializationTurn) -> BehaviorActed<Self>

Produce initialization actions before the first event is accepted.

fn transition( &mut self, _: ActiveTurn, event: Self::Event, ) -> BehaviorActed<Self>

Fold exactly one event into explicit actions and the next behavior.

fn layer<L>(self, layer: L) -> <L as BehaviorLayer<Self>>::Output

where Self: Sized, L: BehaviorLayer<Self>,

Apply one statically dispatched construction layer.

impl<B: Behavior + BehaviorBase> BehaviorBase for Periodic<B>

type Base = <B as BehaviorBase>::Base

fn base(&self) -> &Self::Base