Fixed smallvec implementations to process elements inside.

[xkikeg]

Now there's one drawback that in some case SmallVec won't be supported where A is still smallvec::Array but isn't [T; N]. However, it should be OK in reality, given smallvec itself is going to be SmallVec<T, N> instead of SmallVec<[T; N]> with removing this.

Context: servo/rust-smallvec#183

Closes #89

[fujiapple852]

Hi @xkikeg and thanks for another PR!

So as I understand it:

• smallvec 1.x is defined as SmallVec<A: Array> where Array is a trait with an Item associated type
• smallvec 2.x is defined as SmallVec<T, const N: usize>

This PR improves the impl from:

impl<A> ToBoundedStatic for smallvec::SmallVec<A> 
where
    A: smallvec::Array + 'static,
    A::Item: Clone

To become:

impl<T, const N: usize> ToBoundedStatic for smallvec::SmallVec<[T; N]>
where
    [T; N]: smallvec::Array<Item = T>,
    [T::Static; N]: smallvec::Array<Item = T::Static>,
    T: ToBoundedStatic

This is clearly an improvement, as we can now convert any SmallVec<[T; N]> where T: ToBoundedStatic.

The limitation, as you note, is that it is restricting the usage to SmallVec<[T; N]> rather than the more general SmallVec<A> where A: Array. Not an issue for smallvec 2.x but could be a limitation for smallvec 1.x users.

I had a try and generalising it for the current smallvec 1.x version and came up with this (and similar for IntoBoundedStatic):

impl<A, T> ToBoundedStatic for smallvec::SmallVec<A>
where
    A: smallvec::Array<Item = T> + ToBoundedStatic,
    T: ToBoundedStatic,
    <A as ToBoundedStatic>::Static: smallvec::Array<Item = T::Static>,
{
    type Static = smallvec::SmallVec<A::Static>;

    fn to_static(&self) -> Self::Static {
        self.iter().map(ToBoundedStatic::to_static).collect()
    }
}

To make this work I also had to remove the Copy restriction from impl<T, const N: usize> ToBoundedStatic for [T; N] which is possible these days thanks to core::array::from_fn.

I changed:

impl<T, const N: usize> ToBoundedStatic for [T; N]
where
    T: ToBoundedStatic + Copy,
{
    type Static = [T::Static; N];

    fn to_static(&self) -> Self::Static {
        // Note that we required that `T` is `Copy` here whereas the `IntoBoundedStatic` impl does not.
        self.map(|item| item.to_static())
    }
}

To become:

impl<T, const N: usize> ToBoundedStatic for [T; N]
where
    T: ToBoundedStatic,
{
    type Static = [T::Static; N];

    fn to_static(&self) -> Self::Static {
        core::array::from_fn(|i| self[i].to_static())
    }
}

I pushed a WIP commit to this PR, what do you think?

Perhaps it would make sense to do this for smallvec 1.x and then move to your solution once smallvec 2.x is released? Alternately we could leave it as-is for now and then merge your solution once smallvec 2.x is released.

[xkikeg]

Thanks for suggestions! Your impl seems good so no objections for going with that approach (A: Array<Item=T>).

[fujiapple852]

@xkikeg merged, thanks. Do you need this immediately? If not i'd prefer to hold off on a release until some other changes land.

[xkikeg]

Thanks! now I don't need this (foturunately or unfortunately Vec is slightly faster than SmallVec for my use case so I have no motivation to use SmallVec)