3 
use std::sync::Arc;

trait Trait {}
struct TraitImpl {}
impl Trait for TraitImpl {}

fn main() {
    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Arc::new(value);    // compiles
    let _: Arc<dyn Trait> = value.into();       // doesn't compile
}

结果

error[E0277]: the trait bound `std::sync::Arc<dyn Trait>: std::convert::From<TraitImpl>` is not satisfied
  --> src/main.rs:10:35
   |
10 |     let _: Arc<dyn Trait> = value.into();       // doesn't compile
   |                                   ^^^^ the trait `std::convert::From<TraitImpl>` is not implemented for `std::sync::Arc<dyn Trait>`
   |
   = help: the following implementations were found:
             <std::sync::Arc<T> as std::convert::From<T>>
             <std::sync::Arc<T> as std::convert::From<std::boxed::Box<T>>>
             <std::sync::Arc<[T]> as std::convert::From<&[T]>>
             <std::sync::Arc<[T]> as std::convert::From<std::vec::Vec<T>>>
           and 8 others
   = note: required because of the requirements on the impl of `std::convert::Into<std::sync::Arc<dyn Trait>>` for `TraitImpl`

（游乐场）

为什么Arc::new(value)编译但不编译value.into()？我不明白为什么Arc<T>::new()不满意而满意From<T>::from。

impl<T> Arc<T> {
    pub fn new(data: T) -> Arc<T>
}

impl<T> From<T> for Arc<T> {
    fn from(t: T) -> Arc<T>
}
4

2 回答 2

8

你的两条线有根本的区别。第一个：

let _: Arc<dyn Trait> = Arc::new(value);

该模式对于 的分辨率并不重要Arc::new()，因为它的定义如您所述：

impl<T> Arc<T> {
    pub fn new(data: T) -> Arc<T>
}

所以类型T是从valuethat is的类型推导出来的TraitImpl，并且 anArc<TraitImpl>被创建。然后这种类型被隐式地强制转换为大小，Arc<dyn Trait>并且所有编译都很好。

但第二行更狡猾：

let _: Arc<dyn Trait> = value.into();

由于编译器中没有into函数在范围内搜索任何特征并找到，因此定义为：TraitImplInto<T>::into()

pub trait Into<T> {
    fn into(self) -> T;
}

现在编译器想知道那会是什么类型T。由于是函数的返回值，所以猜测T是Arc<dyn Trait>。现在唯一有趣的实现Into是From：

impl<X, T> Into<T> for X where
    T: From<X>

这X是TraitImpl和T是Arc<dyn Trait>。如果您查看 Arcfor的 impl From，它包含很多，但没有一个适用。这是最相似的：

impl<T> From<T> for Arc<T>

然后，编译器显示一些失败的候选并发出错误。

TL ; DR; 是您实际上想要进行两次转换： from TraitImpltoArc<TraitImpl>和 from Arc<TraitImpl>to Arc<dyn Trait>。但是你不能在一个单一的强制中做到这两个，编译器必须以某种方式拼写出中间类型。

于 2020-05-14T15:10:44.527 回答
2

对于所有通用的 Rust 代码Sized，任何T. 这个：

fn func<T>(t: &T) {}

其实是这样的：

fn func<T: Sized>(t: &T) {}

这可能并不总是您想要的，因此这是您必须明确选择退出的唯一特征，如下所示：

fn func<T: ?Sized>(t: &T) {}

所以在你的情况下：

impl<T> From<T> for Arc<T> {
    fn from(t: T) -> Arc<T>
}

实际上是：

impl<T: Sized> From<T> for Arc<T> {
    fn from(t: T) -> Arc<T>
}

这就是为什么你不能some_value.into()，Arc<dyn Anything>因为所有 trait 对象都没有大小。

至于为什么首先存在这种限制，我们可以通过查看 的定义来确定From<T>：

pub trait From<T> {
    fn from(T) -> Self;
}

from(T)意味着它必须取一些T并将其放入函数的调用堆栈中，这意味着T在编译时必须具有已知的大小，因此必须是Sized.

更新

所以这也适用，Arc::new(T)因为该函数是在 impl 块中定义的，如下所示：

impl<T> for Arc<T> {
    fn new(T) -> Arc<T> {
        ...
    }
}

当您调用时，Arc::new(TraitImpl);您确实使用Sized类型调用它，因为TraitImpl的大小在编译时是已知的，但是变量绑定会触发未调整大小的强制let，因为您要求 Rust 将其Arc<TraitImpl>视为Arc<dyn Trait>.

当您调用时，不会触发这种大小不一的强制，value.into()因为From<T>只接受Sized类型。

但是，如果您决心使用From<T>，您可以这样做：

use std::sync::Arc;

trait Trait {}
struct TraitImpl {}
impl Trait for TraitImpl {}

fn main() {
    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Arc::new(value); // compiles
    let value = TraitImpl {};
    let _: Arc<dyn Trait> = <Arc<TraitImpl>>::from(value); // also compiles
}

在此示例中，您清楚地表明您将在触发未调整大小的强制转换之前从一个大小类型转换为另一个大小类型，即TraitImplto 。Arc<TraitImpl>Arc<TraitImpl>Arc<dyn Trait>

以下是其他变体：

use std::sync::Arc;

trait Trait {}
struct TraitImpl {}
impl Trait for TraitImpl {}

fn main() {
    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Arc::new(value); // compiles

    let value = TraitImpl {};
    let _: Arc<dyn Trait> = <Arc<TraitImpl>>::from(value); // compiles

    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Arc::from(value); // compiles, can infer Arc<TraitImpl> here

    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Into::<Arc<TraitImpl>>::into(value); // compiles

    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Into::<Arc<_>>::into(value); // compiles, can infer Arc<TraitImpl> here

    let value = TraitImpl {};
    let _: Arc<dyn Trait> = Into::into(value); // doesn't compile, infers Arc<dyn Trait> here
}
于 2020-05-14T14:03:26.643 回答