Struct Key 

pub struct Key(/* private fields */);

Opaque handle to an allocated slot.

A Key is simply an index into the slab. It does not contain a generation counter or any other validation mechanism.

Design Rationale: No Generational Indices

This slab intentionally omits generational indices (ABA protection). Why?

The slab is dumb storage, not a source of truth.

In real systems, your data has authoritative external identifiers:

• Exchange order IDs in trading systems
• Database primary keys in web services
• Session tokens in connection managers

When you receive a message referencing an entity, you must validate against the authoritative identifier anyway:

fn on_fill(fill: Fill, key: Key) {
    let Some(order) = slab.get(key) else { return };

    // This check is REQUIRED regardless of generational indices
    if order.exchange_id != fill.exchange_id {
        panic!("order mismatch");
    }

    // Process...
}

Generational indices would catch the same bug that domain validation catches, but at a cost of ~8 cycles per operation. Since domain validation is unavoidable, generations provide no additional safety—only overhead.

If a stale key reaches the slab, your architecture has a bug. The fix is to correct the architecture (clear ownership, proper state machines), not to add runtime checks that mask the underlying problem.

Sentinel

Key::NONE represents an invalid/absent key, useful for optional key fields without Option overhead.

Implementations

impl Key

pub const NONE: Self

Sentinel value representing no key / invalid key.

Equivalent to SLOT_NONE. Check with is_none.

pub const fn index(self) -> u32

Returns the slot index.

For bounded slabs, this is the direct slot index. For unbounded slabs, this encodes chunk and local index via power-of-2 arithmetic.

pub const fn is_none(self) -> bool

Returns true if this is the Key::NONE sentinel.

pub const fn is_some(self) -> bool

Returns true if this is a valid key (not Key::NONE).

pub const fn into_raw(self) -> u32

Returns the raw u32 representation.

Useful for serialization or FFI.

pub const fn from_raw(value: u32) -> Self

Constructs a key from a raw u32 value.

No safety invariants—any u32 is valid. However, using a key not returned by this slab’s insert will return None or wrong data.

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl Hash for Key

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Key

fn eq(&self, other: &Key) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Key

impl Eq for Key

impl StructuralPartialEq for Key