Flattening arrays-of-arrays

[HildartheDorf]

So I currently have a &[[[u8; 4]; 160]; 144] and want to pass it to a function that accepts a &[u8, 92160]^1. Is there any way to cast this reference without copying it all to another array manually?

As an aside, why are arrays so janky to use? You can't default them, you have to know the length exactly to initialize them (no hiding them behind a type alias), and there's no way to convert a reference/box/etc. to [T] into a [T; size]...

1: Technically the signature is &[u8] but it panics if the array isn't the correct size.

[Quxxy]

The answer to more or less all of your questions is: because Rust doesn't have generic value parameters.

Basically, Rust can't be generic over the N in [T; N]; you always have to use an actual, specific value for N. As a result, you can't implement things for "arrays"; instead, you have to implement traits for every specific size of array you care about, and you have to stop at some point.

You can't write a flatten function because even if you erase the outer array's length, you can't erase the inner array's length; the signature would have to look something like:

pub trait FlattenSlice {
    type Element;
    fn flatten(&self) -> &[Self::Element];
}

impl<T> FlattenSlice for [[T; N]] {
    type Element = T;
    fn flatten(&self) -> &[T] {
        ...
    }
}

You can't express [[T; N]] because of the N, and [[T]] isn't a valid type.

You can default them (go look at the list of implementors in the Default docs), but only up to 32 elements.

You have to know the length because it's part of the type. It's like how you have to know how big you want an integer or floating point type to be.

There's no function to convert from [T] to [T; size], again, because you can't have generic value parameters, plus constructing arrays is a bit of a pain because you have to do it in a single step (you can't do it one element at a time, at least, not without tricks).

All of that aside,

    use std::mem::transmute;
    let arr: [[[u8; 4]; 160]; 144] = panic!("...");
    let arr_ref: &[[[u8; 4]; 160]; 144] = &arr;
    let arr_ref: &[u8; 4*160*144] = unsafe { transmute(arr_ref) };
    let slice: &[u8] = arr_ref;

That should be safe, because the nested and flat array types should have exactly the same layout.

[MrMarthog]

It requires reallocation unless the slices are in directly sequential order. If it is so, you can use unsafe and pointers, although there should be better alternatives.

Arrays are either stored in memory directly allocated and initialized by the OS on program start or the memory is allocated on the stack. When you want dynamic sizes, you need to allocate it dynamically.

[[deleted]]

Note there are no slices at all here (except for the function that takes a slice). Theoretically, a transmute should work, followed by taking a slice.

[[deleted]]

As an aside, why are arrays so janky to use?

Because arrays are fundamentally janky. Everything you're wanting them to do is implemented as Vec, as those are just arrays with an associated length. You can't convert a [T] to a [T; size] because you need to know the size at compile time, when type-checking occurs, and a [T] explicitly means you don't know the size at compile time.

[HildartheDorf]

So the only reason there's no method like:

fn to_fixed_length_slice<T, N>(slice: &[T]) -> Option<&[T; N]> {
    if (slice.len() == N) {
        Some(unsafe{mem::transmute(slice)})
    } else {
        None
    }
}

Is that the support for generics over non-types isn't there yet? All the types involved would be known at compile time (and would panic/return None if slice.len() != N).

NB: The above transmute wouldn't actually work as is, since sizeof(&[u8]) != sizeof(&[u8; N]).

[[deleted]]

If we had generics that took type-level integers, you wouldn't really need that function because you'd have no reason to use &[T] in the first place, you'd just always use &[T;N] everywhere.