Crate dyn_stack

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.

Examples:

use core::mem::MaybeUninit;
use dyn_stack::{DynStack, StackReq};
use reborrow::ReborrowMut;

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

{
    // We can have nested allocations.
    // 3×`i32`
    let (array_i32, substack) = stack.rb_mut().make_with::<i32, _>(3, |i| i as i32);
    // and 4×`u8`
    let (mut array_u8, _) = substack.make_with::<u8, _>(4, |_| 0);

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

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

    assert_eq!(array_u8[0], 1);
    assert_eq!(array_u8[1], 0);
    assert_eq!(array_u8[2], 0);
    assert_eq!(array_u8[3], 0);
}

// We can also have disjoint allocations.
{
    // 3×`i32`
    let (mut array_i32, _) = stack.rb_mut().make_with::<i32, _>(3, |i| i as i32);
    assert_eq!(array_i32[0], 0);
    assert_eq!(array_i32[1], 1);
    assert_eq!(array_i32[2], 2);
}

{
    // or 4×`u8`
    let (mut array_u8, _) = stack.rb_mut().make_with::<i32, _>(4, |i| i as i32 + 3);
    assert_eq!(array_u8[0], 3);
    assert_eq!(array_u8[1], 4);
    assert_eq!(array_u8[2], 5);
    assert_eq!(array_u8[3], 6);
}

Modules

mem

Structs

DynArray

Owns an unsized array of data, allocated from some stack.

DynStack

Stack wrapper around a buffer of uninitialized bytes.

GlobalMemBuffer

Buffer of uninitialized bytes to serve as workspace for dynamic arrays.

GlobalPodBuffer

Buffer of initialized bytes to serve as workspace for dynamic POD arrays.

PodStack

Stack wrapper around a buffer of bytes.

SizeOverflow

Size overflow error during the computation of stack allocation requirements.

StackReq

Stack allocation requirements.

Traits

ReborrowMut

Mutable reborrowing.