如何调用在盒装特征对象上使用 self 的方法？

Question

我有以下实现的草图：

trait Listener {
    fn some_action(&mut self);
    fn commit(self);
}

struct FooListener {}

impl Listener for FooListener {
    fn some_action(&mut self) {
        println!("{:?}", "Action!!");
    }
    
    fn commit(self) {
        println!("{:?}", "Commit");
    }
}

struct Transaction {
    listeners: Vec<Box<dyn Listener>>,
}

impl Transaction {
    fn commit(self) {
        // How would I consume the listeners and call commit() on each of them?
    }
}

fn listener() {
    let transaction = Transaction {
        listeners: vec![Box::new(FooListener {})],
    };
    transaction.commit();
}

我可以让Transactions 带有监听器，当该事务发生某些事情时，它们会调用监听器。由于Listener 是一个特征，我存储了一个Vec<Box<Listener>>。

我很难为Transaction 实施commit。不知何故，我必须通过在每个存储的 Listeners 上调用 commit 来消耗这些盒子，但据我所知，我无法将东西移出盒子。

我将如何在提交时使用我的听众？

Answer 1

不允许将commit 应用于装箱对象，因为特征对象不知道它的大小（并且它在编译时不是常量）。由于您计划将侦听器用作盒装对象，您可以做的是确认将在盒子上调用 commit 并相应地更改其签名：

trait Listener {
    fn some_action(&mut self);
    fn commit(self: Box<Self>);
}

struct FooListener {}

impl Listener for FooListener {
    fn some_action(&mut self) {
        println!("{:?}", "Action!!");
    }

    fn commit(self: Box<Self>) {
        println!("{:?}", "Commit");
    }
}

这使Transaction 可以在您编写它时进行编译，因为在FooListener 的实现中Self 的大小是众所周知的，并且完全可以将对象移出框并同时使用两者。

此解决方案的价格是 Listener::commit 现在需要 Box。如果这不可接受，您可以在 trait 中同时声明 commit(self) 和 commit_boxed(self: Box<Self>)，要求所有类型都实现这两者，可能使用私有函数或宏来避免代码重复。这不是很优雅，但它可以同时满足盒装和非盒装用例而不会损失性能。

Answer 2

启用unsized_locals 功能后，自然码works as-is：

// 1.37.0-nightly 2019-06-03 6ffb8f53ee1cb0903f9d
#![feature(unsized_locals)]

// ...

impl Transaction {
    fn commit(self) {
        for l in self.listeners {
            l.commit()
        }
    }
}

Answer 3

接受的答案显示了当您有机构修改原始 Listener 特征时该怎么做。如果您没有该选项，即如果您控制 Transaction 类型，但不控制 Listener 及其实现，请继续阅读。

首先，我们创建一个对象安全的辅助 trait，因为它的任何方法都不会消耗 self：

trait DynListener {
    fn some_action(&mut self);
    fn commit(&mut self);
}

要在Listener 可用的任何地方使用此特征，我们将提供该特征的blanket 实现。通常这样的实现会为所有类型T: Listener 实现DynListener。但这在这里不起作用，因为Listener::commit() 需要消耗self，而DynListener::commit() 只接收一个引用，因此调用Listener::commit() 将无法编译，并出现“无法移出借用内容”。为了解决这个问题，我们为Option<T> 实现了DynListener。这允许我们使用Option::take() 来获取一个拥有的值以传递给Listener::commit()：

impl<T: Listener> DynListener for Option<T> {
    fn some_action(&mut self) {
        // self is &mut Option<T>, self.as_mut().unwrap() is &mut T
        self.as_mut().unwrap().some_action();
    }

    fn commit(&mut self) {
        // self is &mut Option<T>, self.take().unwrap() is T
        self.take().unwrap().commit();
    }
}

DynListener::commit() 从Option 中取出值，在该值上调用Listener::commit()，并将选项保留为None。这是因为在每个 T 的大小已知的一揽子实现中该值不是“未调整大小的”。缺点是我们可以在同一个选项上多次调用DynListener::commit()，除了第一次尝试在运行时出现恐慌。

剩下的工作就是修改Transaction以利用这个：

struct Transaction {
    listeners: Vec<Box<dyn DynListener>>,
}

impl Transaction {
    fn commit(self) {
        for mut listener in self.listeners {
            listener.commit();
        }
    }
}

fn listener() {
    let transaction = Transaction {
        listeners: vec![Box::new(Some(FooListener {}))],
    };
    transaction.commit();
}

Playground