如何构建 Rc<str> 或 Rc<[T]>？

Question

我想创建一个Rc<str>，因为我想减少访问Rc<String> 所需的2 个指针的间接性。我需要使用Rc，因为我确实拥有共享所有权。我在another question 中详细介绍了我在字符串类型方面遇到的更具体的问题。

RChas a ?Sized bound:

pub struct Rc<T: ?Sized> { /* fields omitted */ }

我还听说 Rust 1.2 将适当支持在 Rc 中存储未调整大小的类型，但我不确定这与 1.1 有何不同。

以str 为例，我的naive attempt（也是this，用于从String 构建）失败并显示：

use std::rc::Rc;

fn main() {
    let a: &str = "test";
    let b: Rc<str> = Rc::new(*a);
    println!("{}", b);
}

error[E0277]: the trait bound `str: std::marker::Sized` is not satisfied
 --> src/main.rs:5:22
  |
5 |     let b: Rc<str> = Rc::new(*a);
  |                      ^^^^^^^ `str` does not have a constant size known at compile-time
  |
  = help: the trait `std::marker::Sized` is not implemented for `str`
  = note: required by `<std::rc::Rc<T>>::new`

很明显，为了创建一个Rc<str>，我需要复制整个字符串：RcBox 本身就是一个未调整大小的类型，将字符串本身存储在弱指针和强指针旁边——上面的天真代码没有甚至没有意义。

有人告诉我不能实例化这种类型，而是用大小为T 的Rc<T> 实例化一个T，然后将其强制为一个未调整大小的类型。给出的示例用于存储 trait 对象：首先创建 Rc<ConcreteType>，然后强制转换为 Rc<Trait>。但这也没有任何意义：this 和 this 都不起作用（而且你不能从 &str 或 String 强制转换为 str）。

Answer 1

从 Rust 1.21.0 开始，按照 RFC 1845 的要求，现在可以创建 Rc<str> 或 Arc<str>：

use std::rc::Rc;
use std::sync::Arc;

fn main() {
    let a: &str = "hello world";
    let b: Rc<str> = Rc::from(a);
    println!("{}", b);

    // or equivalently:
    let b: Rc<str> = a.into();
    println!("{}", b);

    // we can also do this for Arc,
    let a: &str = "hello world";
    let b: Arc<str> = Arc::from(a);
    println!("{}", b);
}

(Playground)

参见<Rc as From<&str>> 和<Arc as From<&str>>。

Answer 2

可以通过强制转换和as-casts 从固定大小的数组创建Rc<[T]>，例如强制可以如下进行：

use std::rc::Rc;

fn main() {
    let x: Rc<[i32; 4]> = Rc::new([1, 2, 3, 4]);

    let y: Rc<[i32]> = x;

    println!("{:?}", y);
}

但是，这不适用于字符串，因为它们没有原始固定大小的等价物来创建第一个值。有可能做不安全的事情，例如通过创建一个 UTF-8 编码的Rc<[u8]> 并将其转换为Rc<str>。理论上 crates.io 上可能有一个 crate，但我目前找不到。

另一种选择是owning_ref，它本身并不完全是std::rc::Rc，但应该允许，例如，让RcRef<..., str> 指向Rc<String>。 （如果一个人统一使用RcRef 代替Rc，这种方法效果最好，但构造除外。）

extern crate owning_ref;
use owning_ref::RcRef;
use std::rc::Rc;

fn main() {
    let some_string = "foo".to_owned();

    let val: RcRef<String> = RcRef::new(Rc::new(some_string));

    let borrowed: RcRef<String, str> = val.map(|s| &**s);

    let erased: RcRef<owning_ref::Erased, str> = borrowed.erase_owner();
}

擦除意味着RcRef<..., str>s 可以来自多个不同的来源，例如RcRef<Erased, str> 也可以来自字符串文字。

注意。在撰写本文时，使用 RcRef 进行擦除需要夜间编译器，并且取决于 owning_ref 和 nightly 功能：

[dependencies]
owning_ref = { version = "0.1", features = ["nightly"] }