Struct PriorHandler 

pub struct PriorHandler<'r, R: RngCore> {
    pub rng: &'r mut R,
    pub trace: Trace,
}

Handler for prior sampling - generates fresh random values from distributions.

This is the foundational interpreter that implements standard “forward sampling” from probabilistic models. It draws fresh values from distributions and accumulates log-probabilities in the trace.

Example:

let model = sample(addr!("x"), Normal::new(0.0, 1.0).unwrap())
    .bind(|x| observe(addr!("y"), Normal::new(x, 0.5).unwrap(), 1.2)
        .map(move |_| x));

let mut rng = StdRng::seed_from_u64(42);
let (result, trace) = runtime::handler::run(
    PriorHandler { rng: &mut rng, trace: Trace::default() },
    model
);

assert!(result.is_finite());
assert!(trace.log_likelihood.is_finite());

Fields

rng: &'r mut R

Random number generator for sampling.

trace: Trace

Trace to accumulate execution history.

Trait Implementations

impl<'r, R: RngCore> Handler for PriorHandler<'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.