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();
}

我想创建一个多态对象（trait 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;

然后它成功编译但是：

为什么我们需要Sized？如果我们不能从特征对象中使用此方法，则会违反多态性。

我们实际上无法使用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

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

Answer 1

特征和特征

在Rust中，您可以使用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)
}

为什么我不能使用任何特质作为一种类型？什么是对象安全？

这是一个技术限制。

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

相关类型，
相关常数，
相关的通用函数，
签名中与Self相关联的函数。
......也许是其他人...... 。

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

早期：如果上面有任何一种，请拒绝使用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或{{1} }。 Fn是下一个更通用的方法，所以：

FnMut

这使pub trait Messenger : Sync + Send { fn send_embed(&self, u64, &str, f: &FnMut(String) -> String) -> Option<u64>; }特质对象安全，因此您可以使用Messenger，&Messenger，......

Answer 2

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

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

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

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

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

（Playground）

对于每个可以为send_embed的类型而不是Fn(String) -> String，它现在接受特征对象引用。（您也可以使用Box<Fn()>或类似的）。您必须使用Fn或FnMut而不是FnOnce，因为后者按值self取值，即它也不是对象安全的（调用者没有＆＃39;知道要传递的大小是封闭的self参数。）

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

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

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

Answer 3

无法制作通用方法object-safe，因为您无法使用它实现vtable。 @ChrisEmerson's answer详细解释了原因。

在你的情况下，你可以通过使send_embed取一个特征对象而不是泛型参数来制作f对象特征。如果您的函数接受f: F where F: Fn(X) -> Y，则可以接受f: &Fn(X) -> Y，类似于FnMut f: &mut FnMut(X) -> Y。由于Rust不支持移动未经过类型化的类型，因此FnOnce更加棘手，但您可以尝试将其装箱：

//           ↓ 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));

如果您不想使用不稳定的功能，可以使用包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));

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

3 个答案: