Struct SafeReplayHandler 

pub struct SafeReplayHandler<'r, R: RngCore> {
    pub rng: &'r mut R,
    pub base: Trace,
    pub trace: Trace,
    pub warn_on_mismatch: bool,
}

Safe version of ReplayHandler that gracefully handles trace inconsistencies.

SafeReplayHandler replays model execution like ReplayHandler, but handles type mismatches and missing addresses gracefully by logging warnings and sampling fresh values instead of panicking. Essential for production systems where trace consistency cannot be guaranteed.

Example:

// Create trace with potential inconsistencies
let mut rng = StdRng::seed_from_u64(42);
let (_, base_trace) = runtime::handler::run(
    PriorHandler { rng: &mut rng, trace: Trace::default() },
    sample(addr!("x"), Normal::new(0.0, 1.0).unwrap()) // f64 value
);

// Safe replay handles type mismatch gracefully
let (result, trace) = runtime::handler::run(
    SafeReplayHandler {
        rng: &mut rng,
        base: base_trace,
        trace: Trace::default(),
        warn_on_mismatch: true, // Enable warnings
    },
    sample(addr!("x"), Bernoulli::new(0.5).unwrap()) // Expects bool
);

assert!(trace.total_log_weight().is_finite()); // Continues execution

Fields

rng: &'r mut R

Random number generator for sampling at addresses not in base trace.

base: Trace

Base trace containing values to replay.

trace: Trace

New trace to accumulate the replay execution.

warn_on_mismatch: bool

Whether to log warnings on type mismatches (useful for debugging).

Trait Implementations

impl<'r, R: RngCore> Handler for SafeReplayHandler<'r, R>

fn on_sample_f64(&mut self, addr: &Address, dist: &dyn Distribution<f64>) -> f64

Handle an f64 sampling operation (continuous distributions).

fn on_sample_bool( &mut self, addr: &Address, dist: &dyn Distribution<bool>, ) -> bool

Handle a bool sampling operation (Bernoulli).

fn on_sample_u64(&mut self, addr: &Address, dist: &dyn Distribution<u64>) -> u64

Handle a u64 sampling operation (Poisson, Binomial).

fn on_sample_usize( &mut self, addr: &Address, dist: &dyn Distribution<usize>, ) -> usize

Handle a usize sampling operation (Categorical).

fn on_observe_f64( &mut self, _: &Address, dist: &dyn Distribution<f64>, value: f64, )

Handle an f64 observation operation.

fn on_observe_bool( &mut self, _: &Address, dist: &dyn Distribution<bool>, value: bool, )

Handle a bool observation operation.

fn on_observe_u64( &mut self, _: &Address, dist: &dyn Distribution<u64>, value: u64, )

Handle a u64 observation operation.

fn on_observe_usize( &mut self, _: &Address, dist: &dyn Distribution<usize>, value: usize, )

Handle a usize observation operation.

fn on_factor(&mut self, logw: f64)

Handle a factor operation.

fn finish(self) -> Trace

Finalize the handler and return the accumulated trace.