dynstack

Stack that allows users to allocate dynamically sized arrays.

The stack wraps a buffer of bytes that it uses as a workspace. Allocating an array takes a chunk of memory from the stack, which can be reused once the array is dropped.

Features

std: enables functions that allocate a memory buffer.
nightly: enables a drop check eye patch for DynArray and enhances the std feature with an allocator api.

Examples

```rust use core::mem::MaybeUninit; use dynstack::{DynStack, StackReq}; use reborrow::ReborrowMut;

// We allocate enough storage for 3 i32 and 4 u8. let mut buf = [MaybeUninit::uninit(); StackReq::new::(3) .and(StackReq::new::(4)) .unalignedbytesrequired()]; let mut stack = DynStack::new(&mut buf);

// We can have nested allocations. // 3×i32 let (arrayi32, substack) = stack.rbmut().makewith::(3, |i| i as i32); // and 4×u8 let (mut arrayu8, ) = substack.makewith::(4, |_| 0);

// We can read from the arrays, asserteq!(arrayi32[0], 0); asserteq!(arrayi32[1], 1); asserteq!(arrayi32[2], 2);

// and write to them. array_u8[0] = 1;

asserteq!(arrayu8[0], 1); asserteq!(arrayu8[1], 0); asserteq!(arrayu8[2], 0); asserteq!(arrayu8[3], 0);

// We can also have disjoint allocations. // 3×i32 let (mut arrayi32, _) = stack.rbmut().makewith::(3, |i| i as i32); asserteq!(arrayi32[0], 0); asserteq!(arrayi32[1], 1); asserteq!(array_i32[2], 2);

// or 4×u8 let (mut arrayu8, _) = stack.rbmut().makewith::(4, |i| i as i32 + 3); asserteq!(arrayu8[0], 3); asserteq!(arrayu8[1], 4); asserteq!(arrayu8[2], 5); asserteq!(array_u8[3], 6); ```