Trait SubsliceToArrayMut

pub trait SubsliceToArrayMut<T, const N: usize> {
    // Required method
    fn subslice_to_array_mut<const START: usize, const END: usize>(
        &mut self,
    ) -> &mut [T; N];
}

Conversion from a subslice to a mutable reference to an array, with compile-time checks on the START..END range used to mutably index into a source slice.

Required Methods

fn subslice_to_array_mut<const START: usize, const END: usize>( &mut self, ) -> &mut [T; N]

Compile-time checked version of code like (&mut slice[START..END]).try_into().unwrap() for converting part of a mutable slice into a mutable reference to an array of length N.

The function confirms at compile time that START <= END and N == END - START. A compile-time error is thrown if this requirement is not met.

This internally uses subslice_to_array_mut; if you need to explicitly set the T or N generics, you should directly use subslice_to_array_mut, but in most cases this wrapper is more convenient.

Panics

Panics if any index in the START..END range is out-of-bounds for the provided slice. We cannot check that at compile time.

Examples

use subslice_to_array::SubsliceToArrayMut as _;
let data: &mut [u8] = &mut [0, 1, 2, 3, 4];
*data.subslice_to_array_mut::<1, 3>() = 0xffff_u16.to_le_bytes();
assert_eq!(
    data,
    &mut [0, 255, 255, 3, 4],
);

let data: &mut [u8] = &mut [0, 1, 2, 3, 4, 5, 6, 7, 8];
assert_eq!(
    data.subslice_to_array_mut::<0, 4>(),
    &mut [0, 1, 2, 3],
);
assert_eq!(
    data.subslice_to_array_mut::<4, 9>(),
    &mut [4, 5, 6, 7, 8],
);

fn fn_that_only_gets_a_slice(bytes: &mut [u8]) -> Option<&mut [u8; 4]> {
    if bytes.len() < 5 {
        None
    } else {
        Some(bytes.subslice_to_array_mut::<1, 5>())
    }
}

assert_eq!(
    fn_that_only_gets_a_slice(data),
    Some(&mut [1, 2, 3, 4]),
);

let mut data_vec: Vec<u8> = vec![4, 2];
let data_arr: &mut [u8; 2] = data_vec.subslice_to_array_mut::<0, 2>();
assert_eq!(data_arr, &mut [4, 2]);

// This is a pretty absurd edge case, but it works.
let mut unit_arr: [(); usize::MAX] = [(); usize::MAX];
let unit_slice: &mut [()] = unit_arr.as_mut_slice();
let unit_arr_ref: &mut [(); usize::MAX] = unit_slice
    .subslice_to_array_mut::<0, {usize::MAX}>();

Compile fail examples

If END - START were computed in release mode without checking that START <= END, the below computation would wrap around to 2. Since we do perform that check, this fails to compile.

use subslice_to_array::SubsliceToArrayMut as _;
let data: &[u32] = &[0];
let data_2: &[u32; 2] = data.subslice_to_array_mut::<{usize::MAX}, 1>();

Below, END - START is not equal to N.

use subslice_to_array::SubsliceToArrayMut as _;
let data: &[u32] = &[0, 1, 2];
let data_3: &[u32; 3] = data.subslice_to_array_mut::<1, 3>();

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T, const N: usize> SubsliceToArrayMut<T, N> for [T]

fn subslice_to_array_mut<const START: usize, const END: usize>( &mut self, ) -> &mut [T; N]

Implementors