Open torkleyy opened 7 years ago
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.
Ah! Thanks for your solution. Yeah, it would be really handy to have these type-level integers.
How about allowing something similar to zig?
let y: [u8; 4] = x[5..][..4]
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);
I think it would be nice to do something like that:
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.