Struct PooledPriorHandler 

pub struct PooledPriorHandler<'a, R: RngCore> {
    pub rng: &'a mut R,
    pub trace_builder: TraceBuilder,
    pub pool: &'a mut TracePool,
}

Optimized handler that uses memory pooling for zero-allocation inference.

PooledPriorHandler combines TraceBuilder efficiency with TracePool reuse to achieve zero-allocation execution after pool warm-up.

Example:

let mut pool = TracePool::new(10);
let mut rng = StdRng::seed_from_u64(42);

// Run model with pooled handler
let (result, trace) = runtime::handler::run(
    PooledPriorHandler {
        rng: &mut rng,
        trace_builder: TraceBuilder::new(),
        pool: &mut pool,
    },
    sample(addr!("x"), Normal::new(0.0, 1.0).unwrap())
);

// Return trace to pool for reuse
pool.return_trace(trace);

// Subsequent runs will reuse pooled traces (zero allocations)
assert!(result.is_finite());

Fields

rng: &'a mut R

trace_builder: TraceBuilder

pool: &'a mut TracePool

Trait Implementations

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