如何在奶牛中使用SmallVec

Question

我想把SmallVec和Cow结合使用。我试过这个：

use smallvec::SmallVec;
use std::borrow::Cow;

fn main() {
    let s = "hello world".to_owned();
    let mut s = Cow::Borrowed(s.as_bytes());
    clear_subslice(&mut s, 2, 6);
}

fn clear_subslice(text: &mut Cow<'_, [u8]>, start: usize, end: usize) {
    match text {
        Cow::Borrowed(v) => {
            if !v[start..end].iter().all(|&c| c == b' ') {
                let mut v = SmallVec::from_slice(v);
                v[start..end].iter_mut().for_each(|c| *c = b' ');
                *text = Cow::Owned(v);
            }
        }
        Cow::Owned(v) => {
            v[start..end].iter_mut().for_each(|c| *c = b' ');
        }
    }
}

error[E0271]: type mismatch resolving `<[u8] as std::borrow::ToOwned>::Owned == smallvec::SmallVec<_>`
  --> src/main.rs:16:25
   |
16 |                 *text = Cow::Owned(v);
   |                         ^^^^^^^^^^^^^ expected struct `std::vec::Vec`, found struct `smallvec::SmallVec`
   |
   = note: expected type `std::vec::Vec<u8>`
              found type `smallvec::SmallVec<_>`

它只适用于将ToOwned实现为特定类型的类型。在本例中，&[u8]使用目标Vec实现了ToOwned。

我试图将ToOwned实现为SmallVec，但没有成功。

是否可以将SmallVec与Cow结合使用？

我知道的一个解决方案是使用自定义Cow enum：

pub enum SmallCow<'a, A: Array> {
    Borrowed(&'a [A::Item]),
    Owned(SmallVec<A>),
}

还有别的办法吗？

Answer 1

事实是，Cow<'a, T>需要T实现ToOwned，而拥有的Cow<'a, T>版本是关联的ToOwned类型Owned。而且，Owned必须实现Borrow<T>。就目前情况而言，Cow<'a, [u8]>只能使用Vec<u8>作为自己的变体，因为[T]实现了以Vec<T>作为Owned关联类型的ToOwned。

我有两种选择给你。您可以自己实现使用不同特征边界的Cow (或者如您建议的那样，只需专门处理您的具体用例)，也可以使用新类型包装[u8]和SmallVec<A>，并在包装器上为[u8]实现ToOwned，在SmallVec<A>包装器上实现Borrow<SliceWrapper<u8>>。我把注意力集中在后者上，因为你似乎已经把前者包括在内了。

newtype是一个包装器，本质上，它声明一个与原始类型等价的新类型，但没有任何特征或方法。通常的方法是使用元组结构。

use small_vec::{Array, SmallVec};

struct SmallVecWrap<A: Array>(SmallVec<A>);

struct SliceWrap<T>([T]);

注意，SliceWrap<T>是一个不大小的类型，因为[T]是，所以我们总是在指针后面使用它。我们这样做很重要，因为当我们在SmallVecWrap<A>上实现SmallVecWrap<A>时，它将是Borrow<SliceWrap<T>>，而不是Borrow<&SliceWrap<T>>。也就是说，Borrow使用不大小的类型作为它的类型参数(我认为没有它是可能的，但是您将有一个额外的间接层，您将无法在片上使用变异方法)。

我在这种方法中遇到的一个主要问题是，似乎没有一种在没有不安全块的情况下将&[u8]转换为&SliceWrap<u8>的方法。这确实有一定的意义，因为没有任何额外的信息，这两种类型在语义上可能是不同的。例如，NonZeroU8也处于类似的情况下，但是如果不检查u8是否为零，则将其转换为NonZeroU8是没有意义的。RFC #1909，不大小的rvalue，可能会对此有所帮助，但我无法让它开始工作。我会注意到，MIRI在测试案例上运行时没有发现任何问题。

这种方法的另一个问题是，您必须始终遵从包装类型(例如，示例代码中的v.0 )，然后重新包装返回的值，或者重新实现所需的所有特性和方法。同样的问题也适用于SmallCow<'a, A>方法，但是您只需要实现Cow<'a, T>的特性和方法，就没有那么多了。

如果您决定始终遵从包装类型的方法，您可能希望将新类型的字段公开(例如SliceWrap<T>(pub [T]))，以便在此模块之外使用它们。

这种方法的最后一个问题是ToOwned。ToOwned需要一个类型来转换，但是SmallVecWrap<A>不是单一类型，即使A元素的类型是固定的。例如，&[u8]可以有效地转换为SmallVecWrap<[u8, 1]>、SmallVecWrap<[u8, 2]>等。一个可能的解决方法是将类型A附加到SliceWrap<T>。

struct SliceWrap<T, A: Array> {
    array: std::marker::PhantomData<A>,
    slice: [T],
}

然后，您可以用ToOwned作为SmallVecWrap<A>来实现SliceWrap<T, A>的Owned。

总之，这是一个完整的例子。

use smallvec::{Array, SmallVec}; // 0.6.10
use std::borrow::{Borrow, Cow, ToOwned};

struct SmallVecWrap<A: Array>(SmallVec<A>);

#[repr(transparent)]
struct SliceWrap<T>([T]);

impl<T> SliceWrap<T> {
    // for convenience
    fn from_slice(slice: &[T]) -> &Self {
        // As far as I can tell, there's no way to do this without unsafe.
        // This should be safe since SliceWrap<T> is transparently a [T].
        // All we're doing is changing a (fat) pointer to a [T]
        // into a (fat) pointer to SliceWrap<T>.
        // I won't claim expertise on this, though.
        unsafe { &*((slice as *const [T]) as *const SliceWrap<T>) }
        //          ^                   ^
        // These parentheses aren't needed, but it's clearer this way
    }

    // I guess we didn't need this
    #[allow(dead_code)]
    fn from_mut_slice(slice: &mut [T]) -> &mut Self {
        // Same caveats apply
        unsafe { &mut *((slice as *mut [T]) as *mut SliceWrap<T>) }
    }
}

impl<A: Array> Borrow<SliceWrap<A::Item>> for SmallVecWrap<A> {
    fn borrow(&self) -> &SliceWrap<A::Item> {
        SliceWrap::from_slice(self.0.borrow())
    }
}

// Note: We have to choose a particular array size
// to use for the owned SmallVec<A>.
const OWNED_ARRAY_SIZE: usize = 4;
impl<T: Clone> ToOwned for SliceWrap<T> {
    type Owned = SmallVecWrap<[T; OWNED_ARRAY_SIZE]>;

    fn to_owned(&self) -> SmallVecWrap<[T; OWNED_ARRAY_SIZE]> {
        SmallVecWrap(self.0.into())
    }
}

fn main() {
    let s = "hello world".to_owned();
    let mut s = Cow::Borrowed(SliceWrap::from_slice(s.as_bytes()));
    clear_subslice(&mut s, 2, 6);
}

fn clear_subslice(text: &mut Cow<'_, SliceWrap<u8>>, start: usize, end: usize) {
    match text {
        Cow::Borrowed(v) => {
            if !v.0[start..end].iter().all(|&c| c == b' ') {
                let mut v = SmallVec::from_slice(&v.0);
                v[start..end].iter_mut().for_each(|c| *c = b' ');
                *text = Cow::Owned(SmallVecWrap(v));
            }
        }
        Cow::Owned(v) => {
            v.0[start..end].iter_mut().for_each(|c| *c = b' ');
        }
    }
}

(游乐场)

第三种选择是:不要使用SmallVec<A>，除非您已经对这些小的分配进行了基准测试并确定这些小的分配正在显著地减缓您的程序。