为什么 trait 中的泛型方法需要调整 trait 对象的大小？

Question

我有这个代码 (playground)：

use std::sync::Arc;

pub trait Messenger : Sync + Send {
    fn send_embed<F: FnOnce(String) -> String>(&self, u64, &str, f: F)
        -> Option<u64> where Self: Sync + Send;
}

struct MyMessenger {
    prefix: String,
}
impl MyMessenger {
    fn new(s: &str) -> MyMessenger {
        MyMessenger { prefix: s.to_owned(), }
    }
}
impl Messenger for MyMessenger {
    fn send_embed<F: FnOnce(String) -> String>(&self, channel_id: u64, text: &str, f: F) -> Option<u64> {
        println!("Trying to send embed: chid={}, text=\"{}\"", channel_id, text);
        None
    }

}

struct Bot {
    messenger: Arc<Messenger>,
}
impl Bot {
    fn new() -> Bot {
        Bot {
            messenger: Arc::new(MyMessenger::new("HELLO")),
        }
    }
}

fn main() {
    let b = Bot::new();
}

我想做一个多态对象（特征Messenger，多态实现之一是MyMessenger）。但是当我尝试编译它时出现错误：

error[E0038]: the trait `Messenger` cannot be made into an object
  --> <anon>:25:5
   |
25 |     messenger: Arc<Messenger>,
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Messenger` cannot be made into an object
   |
   = note: method `send_embed` has generic type parameters

我发现在这种情况下我必须要求Sized，但这并不能解决它。如果我将 send_embed 方法更改为以下内容：

fn send_embed<F: FnOnce(String) -> String>(&self, u64, &str, f: F)
    -> Option<u64> where Self: Sized + Sync + Send;

然后编译成功但是：

1. 这里为什么需要Sized？如果我们不能从 trait 对象中使用此方法，这将违反多态性。

2. 我们实际上不能从Arc<Messenger>使用这个方法然后：

   fn main() {
       let b = Bot::new();
       b.messenger.send_embed(0u64, "ABRACADABRA", |s| s);
   }
   

   给予：

   error[E0277]: the trait bound `Messenger + 'static: std::marker::Sized` is not satisfied
     --> <anon>:37:17
      |
   37 |     b.messenger.send_embed(0u64, "ABRACADABRA", |s| s);
      |                 ^^^^^^^^^^ the trait `std::marker::Sized` is not implemented for `Messenger + 'static`
      |
      = note: `Messenger + 'static` does not have a constant size known at compile-time
   

我完全被困在这里。不知道如何在 trait 中使用带有泛型方法的多态性。有什么办法吗？

Answer 1

性状和性状

在 Rust 中，您可以使用 trait 定义一个由以下组成的接口：

• 关联类型，
• 相关常量，
• 相关函数。

你也可以使用特征：

• 作为泛型参数的编译时界限
• 作为类型，在引用或指针之后。

但是...只有 一些 特征可以直接用作类型。这些特征被标记为对象安全。

现在认为不幸的是，存在单个 trait 关键字来定义全功能和对象安全的特征。

---

插曲：运行时调度如何工作？

当使用 trait 作为类型时：&Trait、Box<Trait>、Rc<Trait>、...运行时实现使用由以下组成的胖指针：

• 数据指针，
• 虚拟指针。

方法调用通过指向虚拟表的虚拟指针分派。

对于这样的特征：

trait A {
    fn one(&self) -> usize;
    fn two(&self, other: usize) -> usize;
}

为X 类型实现，虚拟表看起来像(<X as A>::one, <X as A>::two)。

运行时调度因此由以下人员执行：

• 选择表中的正确成员，
• 使用数据指针和参数调用它。

这意味着<X as A>::two 看起来像：

fn x_as_a_two(this: *const (), other: usize) -> usize {
    let x = unsafe { this as *const X as &X };
    x.two(other)
}

---

为什么我不能使用任何 trait 作为类型？什么是对象安全？

这是一个技术限制。

有许多特征功能无法在运行时调度中实现：

• 关联类型，
• 相关常量，
• 关联的泛型函数，
• 与签名中的Self 关联的函数。
• ...也许其他人...。

有两种方法可以表明此问题：

• early：如果 trait 具有上述任何一种类型，则拒绝使用它，
• 迟到：拒绝在trait 上使用上述任何一种类型。

目前，Rust 选择提早指出问题：不使用上述任何特性的特征被称为 Object Safe，并且可以用作类型。

非对象安全的特征不能用作类型，并立即触发错误。

---

现在呢？

在您的情况下，只需将该方法从编译时多态切换到运行时多态：

pub trait Messenger : Sync + Send {
    fn send_embed(&self, u64, &str, f: &FnOnce(String) -> String)
        -> Option<u64>;
}

有一点小问题：FnOnce 需要搬出f 并且只在这里借用，所以你需要改用FnMut 或Fn。 FnMut 是下一个更通用的方法，所以：

pub trait Messenger : Sync + Send {
    fn send_embed(&self, u64, &str, f: &FnMut(String) -> String)
        -> Option<u64>;
}

这使得Messenger trait 对象安全，因此允许您使用&Messenger、Box<Messenger>、...

Answer 2

动态调度（即通过 trait 对象调用方法）通过 vtable 调用（即使用函数指针）来工作，因为您在编译时不知道它将是哪个函数。

但是，如果您的函数是通用的，则需要对实际使用的 F 的每个实例进行不同的编译（单态化）。这意味着对于每个调用它的不同闭包类型，您将拥有一个不同的 send_embed 副本。每个闭包都是不同的类型。

这两个模型是不兼容的：你不能有一个函数指针适用于不同的类型。

但是，您也可以更改方法以使用 trait 对象，而不是编译时通用：

pub trait Messenger : Sync + Send {
    fn send_embed(&self, u64, &str, f: &Fn(String) -> String)
        -> Option<u64> where Self: Sync + Send;
}

(Playground)

它现在接受一个特征对象引用，而不是为每个可以是 Fn(String) -> String 的类型使用不同的 send_embed。 （您也可以使用Box<Fn()> 或类似名称）。您必须使用Fn 或FnMut 而不是FnOnce，因为后者按值取self，即它也不是对象安全的（调用者不知道作为闭包的@ 传递什么大小987654332@参数）。

您仍然可以使用闭包/lambda 函数调用 send_embed，但它只需要通过引用进行，如下所示：

self.messenger.send_embed(0, "abc", &|x| x);

我更新了 Playground 以包含一个使用引用闭包直接调用 send_embed 的示例，以及通过 Bot 上的通用包装器的间接路由。

Answer 3

不能创建泛型方法object-safe，因为你不能用它实现一个vtable。 @ChrisEmerson's answer详细解释了原因。

在您的情况下，您可以通过使 f 采用特征对象而不是通用参数来使 send_embed 对象特征。如果你的函数接受f: F where F: Fn(X) -> Y，你可以让它接受f: &Fn(X) -> Y，FnMut 接受f: &mut FnMut(X) -> Y。 FnOnce 比较棘手，因为 Rust 不支持移动未调整大小的类型，但您可以尝试将它装箱：

//           ↓ no generic          ↓~~~~~~~~~~~~~~~~~~~~~~~~~~~~ box the closure
fn send_embed(&self, u64, &str, f: Box<FnOnce(String) -> String>) -> Option<u64> 
    where Self: Sync + Send
{
    f("hello".to_string());
    None
}

b.messenger.send_embed(1, "234", Box::new(|a| a));
// note: does not work.

但是，从 Rust 1.17.0 you cannot box an FnOnce and call it 开始，您必须使用 FnBox：

#![feature(fnbox)]
use std::boxed::FnBox;

//                                     ↓~~~~
fn send_embed(&self, u64, &str, f: Box<FnBox(String) -> String>) -> Option<u64> 
    where Self: Sync + Send 
{
    f("hello".to_string());
    None
}

b.messenger.send_embed(1, "234", Box::new(|a| a));

如果您不想使用不稳定的功能，可以使用 crate boxfnonce 作为解决方法：

extern crate boxfnonce;
use boxfnonce::BoxFnOnce;

fn send_embed(&self, u64, &str, f: BoxFnOnce<(String,), String>) -> Option<u64> 
    where Self: Sync + Send 
{
    f.call("hello".to_string());
    None
}

b.messenger.send_embed(1, "234", BoxFnOnce::from(|a| a));