为用户定义类型实现 ToOwned

考虑以下示例代码：

#[derive(Clone)]
struct DataRef<'a> {
    text: &'a str,
}

#[derive(Clone)]
struct DataOwned {
    text: String,
}

我要实施ToOwned for DataRef这样：

impl ToOwned for DataRef<'_> {
    type Owned = DataOwned;

    fn to_owned(&self) -> DataOwned {
        DataOwned {
            text: self.text.to_owned(),
        }
    }
}

从字面上看，这句话有道理吧？但也存在一些问题。

第一个问题是，因为ToOwned提供了一个一揽子实施 https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#implementors:

impl<T> ToOwned for T where T: Clone { ... }

上面的代码会出现编译错误：

error[E0119]: conflicting implementations of trait `std::borrow::ToOwned` for type `DataRef<'_>`
  --> src/main.rs:13:1
   |
13 | impl ToOwned for DataRef<'_> {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: conflicting implementation in crate `alloc`:
           - impl<T> ToOwned for T
             where T: Clone;

好吧，我们可以做出一些妥协。让我们删除#[derive(Clone)] from DataRef。 （但是，在我的实际情况中我不能这样做，因为这是一个破坏性的改变并且没有意义）

然后是第二个问题，关联类型Owned of ToOwned requires https://doc.rust-lang.org/std/borrow/trait.ToOwned.html它实现了Borrow<Self> https://doc.rust-lang.org/std/borrow/trait.Borrow.html.

pub trait ToOwned {
    type Owned: Borrow<Self>;

    fn to_owned(&self) -> Self::Owned;

    ...
}

如果我们实施Borrow for DataOwned正如其定义：

impl<'a> Borrow<DataRef<'a>> for DataOwned {
    fn borrow(&self) -> &DataRef<'a> {
        DataRef { text: &self.text }
    }
}

这显然是不可能的，因为我们无法存储DataRef某处。

所以我的问题是：

• 有什么办法可以实现ToOwned对于上面的例子？

• 考虑上面的问题，就是ToOwned不应该由用户手动实现吗？因为我无法想象一个真实的例子来反对这一点。

• （可选答案）如果更改 std 的定义ToOwned是允许的，是否有任何可能的改进可以使其变得更好？ （允许不稳定和未实现的 Rust 功能）

您看到的问题是因为ToOwned不应该被实施对于参考类型但对于一个参照物。注意什么标准库的实现 https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#implementors看起来像：

impl ToOwned for str
impl ToOwned for CStr
impl ToOwned for OsStr
impl ToOwned for Path
impl<T> ToOwned for [T]

这些都是!Sized, !Clone总是出现在某些通用指针类型内部的类型（例如&str, Box<str>, &Path) 或专门拥有的指针类型 (String包含一个str; PathBuf包含一个Path; Vec<T>包含一个[T]）。的目的ToOwned是允许从参考数据——不是你所说的东西FooRef但实际的&— 到专门拥有的指针类型，以这样的方式进行转换：可逆且一致（这就是Borrow<Self>是关于）。

如果您想获得以下好处Borrow and ToOwned，您需要定义一个不是引用但引用可以指向的类型，如下所示：

use std::borrow::Borrow;
#[repr(transparent)]
struct Data {
    text: str,
}

#[derive(Clone)]
struct DataOwned {
    text: String,
}

impl Borrow<Data> for DataOwned {
    fn borrow<'s>(&'s self) -> &'s Data {
        // Use unsafe code to change type of referent.
        // Safety: `Data` is a `repr(transparent)` wrapper around `str`.
        let ptr = &*self.text as *const str as *const Data;
        unsafe { &*ptr }
    }
}

impl ToOwned for Data {
    type Owned = DataOwned;
    fn to_owned(&self) -> DataOwned {
        DataOwned { text: String::from(&self.text) }
    }
}

但请注意，该策略only适用于单个连续数据块（例如文件中的 UTF-8 字节）str）。没有办法实现Borrow + ToOwned以一种适用于DataOwned其中包含two字符串。 （这可以针对一个字符串和一些固定大小的数据完成，但这仍然具有挑战性，因为 Rust 尚未很好地支持自定义动态大小的类型。）

为了一个人做这一切通常并不值得String包装器，但如果您想对内容强制执行一些更强的类型/有效性不变性（例如“所有字符都是 ASCII”或“字符串（或字符串切片）是格式良好的 JSON 片段”），那么它可能是值得的，and您希望能够与期望的现有通用代码进行交互ToOwned将要执行。

如果您只是想能够调用.to_owned()上的方法DataRef，不用理会ToOwned特征;只需编写一个固有（非特征）方法即可。