Crate grift_arena 

Fixed-Size Arena Allocator

A minimal no-std, no-alloc arena allocator with fixed capacity.

Features

• Fixed-size: All memory pre-allocated at compile time
• No-std, no-alloc: Works in embedded environments with no heap
• Generic: Works with any Copy type
• Interior mutability: Safe access via Cell (no runtime borrow checking overhead)
• O(1) allocation: Free-list based allocation and deallocation
• Mark-and-sweep GC: Trait-based garbage collection via Trace
• Zero dependencies: Only uses core::cell::Cell

Module Organization

The arena allocator is organized into the following modules:

• types - Core types: ArenaIndex, ArenaError, ArenaResult
• arena - Main Arena struct and core operations
• traits - Extension traits: ArenaDelete, ArenaCopy, Trace
• gc - Garbage collection implementation
• iter - Iterator support
• stats - Statistics types: ArenaStats, GcStats

Example

use grift_arena::{Arena, ArenaIndex};

#[derive(Clone, Copy, Debug, PartialEq)]
enum Node {
    Leaf(isize),
    Branch(ArenaIndex, ArenaIndex),
}

let arena: Arena<Node, 1024> = Arena::new(Node::Leaf(0));

// Allocate nodes
let left = arena.alloc(Node::Leaf(1)).unwrap();
let right = arena.alloc(Node::Leaf(2)).unwrap();
let root = arena.alloc(Node::Branch(left, right)).unwrap();

// Access nodes
if let Node::Branch(l, r) = arena.get(root).unwrap() {
    println!("Left: {:?}, Right: {:?}", arena.get(l), arena.get(r));
}

// Free when done
arena.free(root).unwrap();

Re-exports

pub use types::ArenaIndex;

pub use types::ArenaError;

pub use types::ArenaResult;

pub use arena::Arena;

pub use traits::ArenaDelete;

pub use traits::ArenaCopy;

pub use traits::Trace;

pub use stats::ArenaStats;

pub use stats::GcStats;

pub use iter::ArenaIterator;

Modules

arena

Core arena allocator implementation.

gc

Garbage collection implementation.

iter

Iterator support for the arena.

stats

Statistics types for arena usage monitoring.

traits

Trait definitions for arena operations.

types

Core types for the arena allocator.