Question

背景

我遇到一种情况，我想抽象两种不同的操作模式Sparse和Dense。我选择哪一个是编译时间决定。

与这些模式正交，我有多个Kernels。两种模式之间内核的实现细节和签名不同，但是每种模式具有相同的内核。内核将在运行时根据模型文件确定。

我现在想创建一个同时处理模式和内核的BlackBox。

简化代码

我删除了其他内核和稀疏模式。

pub struct XKernel;

pub trait KernelDense {
    fn compute_dense(&self, vectors: &[f32]);
}

impl KernelDense for XKernel {
    fn compute_dense(&self, vectors: &[f32]) {}
}

pub trait KernelCompute<V> {
    fn just_compute_it(&self, vectors: &[V]);
}

impl KernelCompute<f32> for (dyn KernelDense + 'static) {
    fn just_compute_it(&self, v: &[f32]) {
        self.compute_dense(v);
    }
}

pub trait Generalization {
    type V: 'static;

    type OperatorType: KernelCompute<Self::V>;

    fn set_kernel(&self, x: Box<Self::OperatorType>);

    fn compute(&self, v: &[Self::V]);
}

pub struct DenseVariant {
    x: Box<KernelDense>,
}

impl Generalization for DenseVariant {
    type V = f32;
    type OperatorType = KernelDense;

    fn set_kernel(&self, x: Box<KernelDense>) {}

    fn compute(&self, v: &[Self::V]) {
        self.x.compute_dense(v);
    }
}

struct BlackBox<'a, T>
where
    T: Generalization,
{
    computer: T,
    elements: &'a [T::V],
}

impl<'a, T> BlackBox<'a, T>
where
    T: Generalization,
{
    fn runtime_pick_operator_and_compute(&mut self) {
        self.computer.set_kernel(Box::new(XKernel));
        let s = self.elements.as_ref();
        self.computer.compute(s);
    }
}

fn main() {
    // What I eventually want to do:
    // let black_box = BlackBox::<DenseVariant>::new();
    // black_box.runtime_pick_operator_and_compute();
}

Playground

上面的代码会产生错误

error[E0277]: the size for values of type `(dyn KernelDense + 'static)` cannot be known at compilation time
  --> src/main.rs:35:6
   |
35 | impl Generalization for DenseVariant {
   |      ^^^^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `std::marker::Sized` is not implemented for `(dyn KernelDense + 'static)`
   = note: to learn more, visit <https://doc.rust-lang.org/book/second-edition/ch19-04-advanced-types.html#dynamically-sized-types-and-sized>

我尝试添加大量的: Sized（例如，给BlackBox一个where T: Generalization + Sized，最终只会产生不同的错误。

问题

如何为std::marker::Sized实现(dyn KernelDense + 'static) /使该程序进行编译以解决上述意图？
为什么编译器甚至关心Generalization是Sized（即使我将T: Generalization + Sized添加到BlackBox）？ BlackBox（使用Generalization的唯一对象）不是被单一化为Generalization（例如DenseVariant）的东西，然后显然具有{{1} }）？

Answer 1

错误消息令人困惑。 ^^^（误导）指向Generalization，但实际错误为dyn KernelDense，即OperatorType。因此，OperatorType才是真正的Sized。除非您通过添加Sized来另外指定，否则关联类型like generic type parameters具有隐式?Sized绑定：

pub trait Generalization {
    ...
    type OperatorType: ?Sized + KernelCompute<Self::V>;
    ...
}

但是您会立即遇到另一个问题（playground）：

error[E0308]: mismatched types
  --> src/main.rs:59:47
   |
59 |         self.computer.set_kernel(Box::new(XKernel));
   |                                           ^^^^^^^ expected associated type, found struct `XKernel`
   |
   = note: expected type `<T as Generalization>::OperatorType`
              found type `XKernel`

如果您稍稍看一下这行，基本上是编译器在说“ Box<XKernel>我该怎么办？我需要一个Box<T::OperatorType>而我什至不知道{{ 1}}还没有！“

那应该有意义。因为没有规则禁止在T是的情况下添加一种新的变体，所以假设OperatorType：

str

没有规则禁止这些struct StringyVariant; impl Generalization for StringyVariant { type V = f32; type OperatorType = str; fn set_kernel(&self, x: Box<str>) {} fn compute(&self, v: &[f32]) {} } impl KernelCompute<f32> for str { fn just_compute_it(&self, vectors: &[f32]) {} }，但是不可能将impl强制转换为Box<XKernel>，因此Box<str>上的保护语impl必须是错误的。它缺少一项要求：可以将BlackBox强制转换为Box<XKernel>的要求。

在稳定的Rust（自1.28起）中，无法将此要求写为特征绑定，因此您必须编写两个Box<T::OperatorType>（例如，一个用于impl，一个用于{{ 1}}），或者找到其他方法（例如使用BlackBox<DenseVariant>代替强制）。

但是，在每晚的Rust中，您都可以使用BlackBox<SparseVariant>边界和额外的From来解决原始问题，以向编译器暗示它应强制执行有意义的操作：

CoerceUnsized

Here it is in the playground.

当关联类型没有大小时，如何避免需要`std :: marker :: Sized`？

1 个答案: