如何将 SmallVec 与 Cow 一起使用

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]已经ToOwned实现了 target Vec。

我尝试ToOwned以目标为目标实施SmallVec，但没有成功。

可以SmallVec与 一起使用吗Cow？

我知道的一种解决方案是使用自定义Cow枚举：

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

还有其他办法吗？

Answer 1

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

我为你看到了两个选择。您可以使用不同的特征边界来实现您自己的实现Cow（或者按照您的建议，简单地专门针对您的确切用例），或者您可以使用新类型来包装[u8]和并在包装器 for和包装器 for 上SmallVec<A>实现。我将重点关注后者，因为您似乎已经涵盖了前者。ToOwned[u8]Borrow<SliceWrapper<u8>>SmallVec<A>

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

use small_vec::{Array, SmallVec};

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

struct SliceWrap<T>([T]);

请注意，这SliceWrap<T>是一个未调整大小的类型[T]，因此我们将始终在指针后面使用它。我们这样做很重要，因为当我们实现Borrow时SmallVecWrap<A>，它将是Borrow<SliceWrap<T>>，而不是Borrow<&SliceWrap<T>>。也就是说，Borrow使用未调整大小的类型作为其类型参数（我想没有它也可以，但是您将有一个额外的间接层，并且您将无法在切片上使用变异方法）。

我使用这种方法遇到的一个主要问题是，似乎没有一种方法可以在没有不安全块的情况下进行&[u8]转换。&SliceWrap<u8>这确实有一定的意义，因为没有任何额外的信息，这两种类型在语义上可能不同。例如，NonZeroU8处于类似的情况，但在不检查 a 是否为零的情况下将 a 转换u8为 是没有意义的。NonZeroU8RFC #1909，未调整大小的右值，可能会对此有所帮助，但我无法让它工作。我会注意到 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],
}

然后你可以用as来实现ToOwnedfor 。SliceWrap<T, A>OwnedSmallVecWrap<A>

无论如何，这是完整的示例。

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>您还有第三种选择：除非您进行了基准测试并确定这些小分配会显着减慢您的程序，否则不要使用。