Dynamic data structures that do not require a global allocator.
This allows creating dynamic and recursive data structures without dynamic
allocations. The example below makes use of the static-alloc crate to build a
list with static lifetime based on dynamic data. As local memory pools for
fixed capacity FixedVec:
```rust use staticalloc::Bump; use withoutalloc::{FixedVec, alloc::LocalAllocLeakExt};
let mut pool: Bump<[usize; 16]> = Bump::uninit(); // Allocate a vector with capacity of 16 from the slab. let mut vector = pool.fixed_vec(16).unwrap();
let mut num = 0;
// Push mutable ref, not 'static, Copy nor Clone!
vector.push(&mut num);
*vector[0] = 42;
drop(vector); assert_eq!(num, 42); ```
This might be handy if you want to chain boot another kernel and pass it a linked list describing the platform.
```rust use staticalloc::Bump; use withoutalloc::{Box, alloc::LocalAllocLeakExt};
enum List { Nil, Cons(u8, Box<'static, List>), }
static SLAB: Bump<[u8; 1024]> = Bump::uninit();
let base = SLAB.boxed(List::Nil).unwrap(); let one = SLAB.boxed(List::Cons(0, base)).unwrap(); let two = SLAB.boxed(List::Cons(1, one)).unwrap(); ```