特征 `A` 没有为类型 `&'a A + 'a` 实现

Question

我在使用将通用特征对象作为参数的通用函数时遇到问题。当我尝试调用该函数时，编译器抱怨“错误：&'a mut Next<Type=Type> + 'a [E0277] 类型未实现特征 Next”。在我看来，Next 特性对于任何参数 Type 都是对象安全的，因此 Next 应该由任何 &Next<Type> 实现（根据我对 Huon’s Object-Safety article 的阅读);有什么方法可以检查它是否是对象安全的？

顺便说一句，我用 Iterator 做几乎相同的事情没问题，我不知道这有什么不同。

trait Next {
    type Type;
    fn next(&mut self) -> Option<Self::Type>;
}
struct NextImpl<Type> {
    next: Option<Type>,
}
impl<Type> Next for NextImpl<Type> {
    type Type = Type;
    fn next(&mut self) -> Option<Self::Type> {
        let mut ret = None;
        std::mem::swap(&mut self.next, &mut ret);
        ret
    }
}

struct DelegatingNext<'a, Type> {
    delegate: &'a mut Next<Type=Type>,
}
impl<'a, Type> Next for DelegatingNext<'a, Type> {
    type Type = Type;
    fn next(&mut self) -> Option<Self::Type> {
        self.delegate.next()

        // error: the trait `Next` is not implemented for the type `&'a mut Next<Type=Type> + 'a` [E0277]
        // Next::next(&mut self.delegate)
        // ^~~~~~~~~~

        // error: the trait `Next` is not implemented for the type `&'a mut Next<Type=Type> + 'a` [E0277]
        // if (true) {
        // next_next1(&mut self.delegate)
        // ^~~~~~~~~~

        // error: the trait `Next` is not implemented for the type `&'a mut Next<Type=Type> + 'a` [E0277]
        // next_next2(&mut self.delegate)
        //            ^~~~~~~~~~~~~~~~~~
    }
}
fn next_next1<'a, NextType: Next + ?Sized>(m: &'a mut NextType) -> Option<NextType::Type> {
    m.next()
}
fn next_next2<'a, Type>(m: &'a mut Next<Type=Type>) -> Option<Type> {
    m.next()
}
struct DelegatingIterator<'b, T> {
    iter: &'b mut Iterator<Item=T>,
}
impl<'b, T> DelegatingIterator<'b, T> {
    fn next(&mut self) -> Option<T> {
        let iter: &mut Iterator<Item=T> = self.iter;

        iterator_next1(iter)

        // error: the trait `core::marker::Sized` is not implemented for the type `core::iter::Iterator<Item=T>` [E0277]
        // note: `core::iter::Iterator<Item=T>` does not have a constant size known at compile-time
        // iterator_next2(iter)
        // ^~~~~~~~~~~~~~

        // OK
        // iterator_next3(iter)

        // OK
        // iterator_next4(iter)
    }
}
fn iterator_next1<'a, T>(iter: &mut Iterator<Item=T>) -> Option<T> {
    iter.next()
}
fn iterator_next2<It: Iterator>(iter: &mut It) -> Option<It::Item> {
    iter.next()
}
fn iterator_next3<It: Iterator + ?Sized>(iter: &mut It) -> Option<It::Item> {
    iter.next()
}
fn iterator_next4<'a, Item>(iter: &mut Iterator<Item=Item>) -> Option<Item> {
    iter.next()
}

fn main() {
    let mut m = NextImpl {next: Some("hi")};
    let mut delegating_model = DelegatingNext {delegate: &mut m};
    assert!(Some("hi") == delegating_model.next());
    let v: Vec<i32> = vec!(1, 2, 3);
    let mut iter = v.iter();
    assert_eq!(Some(&1), (DelegatingIterator {iter: &mut iter }).next());
}

Answer 1

我认为您正在添加一个额外的间接层。在这种情况下，方法调用 self.delegate.next() 脱糖为 Next::next(self.delegate) - 不需要自动引用（可变或其他）。

错误消息令人困惑，因为您有两个参考级别。你的特质是这样写的：

trait Next {
    fn next(&mut self)
}

这意味着你总是要传入一个&mut Foo。但是，您采用了 second 可变引用，使参数类型成为 &mut &mut NextImpl<Type>。第一个&mut是通过函数参数匹配的，但是后面的类型需要实现Next。但是，&mut NextImpl<Type> 没有实现该特性，只有 NextImpl<Type> 实现了！

您的 Sized 问题非常相似。函数定义为

fn iterator_next2<It: Iterator>(iter: &mut It) -> Option<It::Item>

也就是说，它需要一个对实现 Iterator 的一些具体类型的可变引用。您的调用传递了一个 &mut Iterator - 一个 特征对象 。特征对象是对未知大小的对象的引用，它只知道实现特征的方法。由于您不关心所指事物的大小，因此正确的选择是声明它，就像您所做的那样：

fn iterator_next3<It: Iterator + ?Sized>(iter: &mut It) -> Option<It::Item> {
    iter.next()
}

这非常令人困惑，所以如果我需要尝试以不同的方式解释它，请告诉我。

特征 `A` 没有为类型 `&'a A + 'a` 实现

The trait `A` is not implemented for the type `&'a A + 'a`

rust