A different/improved version of the Pixel trait

[Ogeon]

I would like to reduce the Pixel trait down to something that just converts to and from arrays. It should be more viable now when it's easier to work with arrays, due to const generics and API improvements. The idea I have so far is to have a minimal ArrayRepr trait (a better name is welcome) that takes care of the unsafe array casting, and add on a SliceExt trait and possibly a VecExt trait with more collection specific stuff. The only snag is that Alpha need to have an array representation that is [T; N+1] and there isn't a nice way of representing it, but I think it would be ok to work around with some kind of NextArraySize trait that is implemented for a handful of sizes.

I'm putting it here to see if there's any input or if other people have thought of any better techniques.

Here's a sketch of how I'm imagining it so far:

/// The core trait that pinky promises that casting is safe.
pub unsafe trait ArrayRepr: Sized {
    type Array: ArrayExt;

    fn into_array(self) -> Self::Array {
        // ..
    }

    fn from_array(array: Self::Array) -> Self {
        // ..
    }

    fn as_array(&self) -> &Self::Array {
        // ..
    }

    fn as_array_mut(&mut self) -> &mut Self::Array {
        // ..
    }
}

// This allows us to avoid special casing arrays.
unsafe impl<T, const N: usize> ArrayRepr for [T; N] {
    type Array = Self;
}

unsafe impl<S: RgbStandard, T: Component> ArrayRepr for Rgb<S, T> {
    type Array = [T; 3];
}

/// A temporary replacement for `[T; N + 1]`.
pub trait NextArraySize {
    type NextArray: ArrayExt;
}

// And the same for a few more sizes
impl<T> NextArraySize for [T; 3] {
    type NextArray = [T; 4];
}

// We need to make sure that the inner color uses the same component type as the alpha component.
unsafe impl<C, T, const N: usize> ArrayRepr for Alpha<C, T>
where
    C: ArrayRepr<Array = [T; N]>,
    [T; N]: NextArraySize,
{
    type Array = <[T; N] as NextArraySize>::NextArray;
}

/// Exposes the item type of an array.
pub trait ArrayExt {
    type Item;
}

impl<T, const N: usize> ArrayExt for [T; N] {
    type Item = T;
}

/// This trait is just an example of how I want to move things out of `Pixel`/`ArrayRepr`. A different structure may be better.
pub trait SliceExt {
    type Item: ArrayRepr;

    fn cast_items<T>(&self) -> &[T]
    where
        T: ArrayRepr<Array = <Self::Item as ArrayRepr>::Array>;

    fn cast_items_mut<T>(&mut self) -> &mut [T]
    where
        T: ArrayRepr<Array = <Self::Item as ArrayRepr>::Array>;

    fn from_components(slice: &[<<Self::Item as ArrayRepr>::Array as ArrayExt>::Item]) -> &Self;

    fn as_components(&self) -> &[<<Self::Item as ArrayRepr>::Array as ArrayExt>::Item];

    // ...
}

impl<I: ArrayRepr> SliceExt for [I] {
    type Item = I;

    fn cast_items<T>(&self) -> &[T] 
    where
        T: ArrayRepr<Array = I::Array>,
    {
        // ...
    }

    fn cast_items_mut<T>(&mut self) -> &mut [T]
    where
        T: ArrayRepr<Array = I::Array>,
    {
        // ...
    }

    fn from_components(slice: &[<I::Array as ArrayExt>::Item]) -> &Self {
        // ...
    }

    fn as_components(&self) -> &[<I::Array as ArrayExt>::Item] {
        // ...
    }
}

fn test() {
    let rgba = Srgb::from_array([120u8, 25, 100])
        .with_alpha(10u8)
        .into_array();

    let buffer = vec![Srgb::new(120u8, 25, 100); 1000].as_components();
}

[Ogeon]

Having rust-lang/rust#74985 stabilized would also help with this, since it's essentially the same as some of what I want it to do, but we'll have to make do until that happens.