Struct ByteSlab 

pub struct ByteSlab<const N: usize> { /* private fields */ }

Growable byte slab. Mirrors crate::unbounded::Slab but stores heterogeneous types in fixed-size byte slots.

Grows via independent chunks — no copying, no reallocation of existing slots. Pointers remain valid.

Safety Contract

Construction is unsafe because it opts you into manual memory management. By creating a slab, you accept these invariants:

• Free from the correct slab. Passing a Slot to a different slab’s free() is undefined behavior — it corrupts the freelist. In debug builds, this is caught by debug_assert!.
• Free everything you allocate. Dropping the slab does NOT drop values in occupied slots. Unfreed slots leak silently.
• Single-threaded. The slab is !Send and !Sync.

Why free() is safe

The safety contract is accepted once, at construction. After that:

• Slot is move-only (no Copy, no Clone) — double-free is prevented by the type system.
• free() consumes the Slot — the handle cannot be used after.
• Cross-slab misuse is the only remaining hazard, and it was accepted as the caller’s responsibility at construction time.

Implementations

impl<const N: usize> Slab<N>

pub unsafe fn with_chunk_capacity(chunk_capacity: usize) -> Slab<N>

Creates a new unbounded byte slab with the given chunk capacity.

Safety

See struct-level safety contract.

Panics

Panics if chunk_capacity is zero.

pub fn alloc<T>(&self, value: T) -> Slot<T>

Allocates a value. Never fails — grows if needed.

Panics

• Panics if size_of::<T>() > N
• Panics if align_of::<T>() > 8

pub fn claim(&self) -> ByteClaim<'_>

Reserve a slot without writing. Always succeeds (grows if needed).

The returned super::ByteClaim can be written to with .write(value) or .write_raw(src, size). If dropped without writing, the slot is returned to the freelist.

pub unsafe fn free_raw(&self, ptr: *mut u8)

Free a raw pointer without dropping content.

Safety

ptr must point to a slot in this slab.

pub unsafe fn free_raw_in_chunk(&self, ptr: *mut u8, chunk_idx: usize)

Free a raw pointer with known chunk index. O(1) — no linear scan.

Safety

• ptr must point to a slot in chunk chunk_idx of this slab.

pub unsafe fn alloc_raw(&self, src: *const u8, size: usize) -> *mut u8

Claim a slot and copy raw bytes into it. Returns a raw pointer.

Safety

• src must point to size valid bytes.
• size must be <= N.

Panics

• Panics if size > N.

pub fn free<T>(&self, ptr: Slot<T>)

Frees a value, dropping it and returning the slot to the freelist.

Consumes the handle — the slot cannot be used after this call.

pub fn take<T>(&self, ptr: Slot<T>) -> T

Takes the value out without dropping it, freeing the slot.

Consumes the handle — the slot cannot be used after this call.

Trait Implementations

impl<const N: usize> Debug for Slab<N>

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

Formats the value using the given formatter.