Jak zbudować Rc ​​<str> lub Rc <[T]>?

Question

Chciałbym utworzyć Rc<str>, ponieważ chcę zmniejszyć niedokładność z następujących 2 wskaźników, które wymagają dostępu do Rc<String>. Muszę użyć Rc, ponieważ naprawdę mam wspólną własność. Szczegółowo opisuję w another question bardziej szczegółowe problemy, które mam wokół mojego typu ciągu.

Rc has a ?Sized bound:

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

Słyszałem również, że Rust 1,2 przyjdzie z odpowiednim wsparciem dla przechowywania niezagruntowanej typy w Rc, ale jestem pewien sposób różni się od 1.1.

Biorąc sprawę str jako przykład, mój naive attempt (również this na budowę od String) nie powiedzie się z:

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` 

To jasne, że w celu stworzenia Rc<str>, muszę skopiować cały ciąg: RcBox byłby sam w sobie niezsynchronizowanym typem, przechowującym strunę obok słabych i mocnych wskaźników - powyższy naiwny kod nie ma nawet sensu.

Powiedziano mi, że nie można utworzyć tego typu, ale zamiast tego należy utworzyć instancję Rc<T> o rozmiarze T, a następnie przymusić ją do typu niezmienionego. Podany przykład dotyczy przechowywania obiektu cechy: najpierw stwórz Rc<ConcreteType>, a następnie przymuszaj do Rc<Trait>. Ale to też nie ma sensu: ani this, anidziałać (i nie można przymuszać z &str lub String do str tak).

Answer 1

Utworzenie Rc<[T]> można wykonać za pomocą przymusu i odczytów as z tablic o ustalonych rozmiarach, np. coercions Można to zrobić w następujący sposób:

use std::rc::Rc; 

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

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

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

Jednak to nie działa dla ciągów, ponieważ nie mają one surowe stałe wielkości ekwiwalentu, aby utworzyć pierwszą wartość. Można robić niefajnie, np. tworząc kodowany UTF-8 Rc<[u8]> i transmutujący go do Rc<str>. Teoretycznie może to być skrzynka na crates.io, ale w tej chwili nie mogę jej znaleźć.

Alternatywą jest owning_ref, co nie jest zupełnie sama std::rc::Rc, ale powinna pozwalać na przykład uzyskanie RcRef<..., str> wskazując na w Rc<String>. (To podejście działa najlepiej jeśli używa RcRef równomiernie zamiast Rc wyjątkiem konstrukcji.)

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

Kasowanie oznacza RcRef<..., str> y mogą pochodzić z wielu różnych źródeł, np a RcRef<Erased, str> może pochodzić również z literału.

NB. w czasie pisania, wymazywanie z RcRef wymaga nocne kompilator, w zależności od owning_ref z funkcją nightly:

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

Answer 2

As of Rust 1.21.0 i zgodnie z zaleceniami RFC 1845, tworząc Rc<str> lub Arc<str> jest teraz możliwe:

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)

Patrz <Rc as From<&str>> i <Arc as From<&str>>.