Struct Interner 

pub struct Interner<'a> {
    arena: &'a Arena,
    table: Vec<'a, Option<&'a str>>,
    mask: usize,
    occupied: usize,
    last: Option<&'a str>,
    pub stats: InternStats,
}

Open-addressing intern table over arena-allocated strings.

Fields

arena: &'a Arena

table: Vec<'a, Option<&'a str>>

Slots: None = empty, Some(&'a str) = occupied. BumpVec keeps the table itself inside the arena, so the interner allocates exactly zero bytes outside the arena.

mask: usize

capacity - 1. capacity is always a power of two.

occupied: usize

Number of occupied slots.

last: Option<&'a str>

Inline cache: last successfully-interned string. Long runs of identical interns short-circuit on this single pointer compare.

A 2-slot LRU cache (intended to catch Ruby’s alternating (base, reading, base, reading, …) access pattern) was tried and reverted. Corpus dedup ratio stayed at p50 0.275 / mean 0.308 (identical to the 1-slot baseline), throughput moved within noise. The pattern that would benefit — consecutive rubies sharing a base or reading — is rarer than the design assumed; distinct rubies on distinct words dominate.

stats: InternStats

Diagnostic counters. Updated on every intern call. Useful for benchmarks and the corpus-sweep dedup-ratio report.

Implementations

impl<'a> Interner<'a>

pub fn new_in(arena: &'a Arena) -> Self

Empty interner backed by arena. Initial capacity is INITIAL_CAPACITY.

pub fn with_capacity_in(capacity_hint: usize, arena: &'a Arena) -> Self

Empty interner backed by arena, with the table pre-sized to at least capacity_hint slots (rounded up to a power of two). Use when the caller can estimate the unique-string count up front (e.g. the lex driver knows the registry size).

pub fn intern(&mut self, s: &str) -> &'a str

Intern s and return a stable &'a str pointer to the arena copy. Subsequent calls with byte-equal content return the same pointer.

pub fn unique_strings(&self) -> usize

Number of unique strings currently held in the table.

pub fn capacity(&self) -> usize

Current table capacity.

pub fn avg_probe_length(&self) -> f64

Average probe length per non-cache-hit lookup. Returns 0.0 when no probed lookups have occurred. Used by benchmarks to confirm the hash function and load-factor policy keep the table healthy.

fn grow(&mut self)

Doubles capacity and rebuilds the table via fresh probing.

Trait Implementations

impl<'a> Debug for Interner<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.