Trait SubsliceToArray 

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

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

Required Methods

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

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

This is only implemented for slices &[T] where T is Copy.

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; if you need to explicitly set the T or N generics, you should directly use subslice_to_array, 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::SubsliceToArray as _;
let data: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
assert_eq!(
    data.subslice_to_array::<0, 4>(),
    [0, 1, 2, 3],
);
assert_eq!(
    data.subslice_to_array::<4, 9>(),
    [4, 5, 6, 7, 8],
);

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

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

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

// This is a pretty absurd edge case, but it works.
let unit_arr: [(); usize::MAX] = [(); usize::MAX];
let unit_slice: &[()] = unit_arr.as_slice();
let round_trip: [(); usize::MAX] = unit_slice.subslice_to_array::<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::SubsliceToArray as _;
let data: &[u32] = &[0];
let data_2: [u32; 2] = data.subslice_to_array::<{usize::MAX}, 1>();

Below, END - START is not equal to N.

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

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

Implementors