Allow slicing to fixed-length arrays

[torkleyy]

I think it would be nice to do something like that:

let x = [1, 2, 3, 4];
let y = x[1..2];

Why isn't y of type [i32; 2] now?

I wanted to convert a [f32; 16] to an [[f32; 4]; 4], however there seems to be no easy way to do that.

[SimonSapin]

x[1..2] and x[1..4] are both calls to Trait std::ops::Index::<Range<usize>>::index. The type parameter Range<usize> is the same is both cases, therefore the associated type Index::Output has to be the same, therefore the return type of the index method has to be the same.

So it doesn’t work with the slicing/indexing syntax, but I agree that it would be nice to have some API that does this. However, doing it "right" likely requires type-lever integers. With made-up syntax, it could look like:

impl<T> [T] {
    pub fn as_array<int N>(&self) -> &[T; N] {
        assert_eq!(self.len(), N);
        let ptr = self.as_ptr() as *const [T; N];
        unsafe { &*ptr }
    }
}

In the meantime, you can fake it with a macro like the one used in ring.

I wanted to convert a [f32; 16] to an [[f32; 4]; 4]

If the size is fixed for your program that’s even easier. You can use a similar pattern, casting raw pointers:

fn to_4x4(array: &[f32; 16]) -> &[[f32; 4]; 4] {
    unsafe { &*(array as *const _ as *const _) }
}

However this case is more complicated than as_array above since the slice item type is not the same in and out.

[torkleyy]

Ah! Thanks for your solution. Yeah, it would be really handy to have these type-level integers.

[burdges]

Use the arrayref crate until we get type-level integers or similar.

[LHolten]

How about allowing something similar to zig?
let y: [u8; 4] = x[5..][..4]

[SimonSapin]

Update since my 7-years-old comment above: we now have const generics, and these impls in the standard library:

impl<T, const N: usize> TryFrom<&[T]> for &[T; N]
impl<T, const N: usize> TryFrom<&[T]> for [T; N] where T: Copy

So you can write:

let y: [_; 4] = (&x[5..][..4]).try_into().unwrap();

Maybe with a helper function:

fn const_slice_to<T, const N: usize>(x: &[T]) -> &[T; N] {
    x.try_into().unwarp()
}

let y: [_; 4] = *const_slice_to(x);  // or:
let y = *const_slice_to::<4>(x);