Rust
Tratti di conversione

Osservazioni

A partire dal

Rust's From trait è un tratto generico per la conversione tra tipi. Per qualsiasi due tipi, TypeA e TypeB ,

impl From<TypeA> for TypeB

indica che un'istanza di TypeB è garantita per essere costruibile da un'istanza di TypeA . Un'implementazione di From assomiglia a questo:

struct TypeA {
    a: u32,
}

struct TypeB {
    b: u32,
}

impl From<TypeA> for TypeB {
    fn from(src: TypeA) -> Self {
        TypeB {
            b: src.a,
        }
    }
}

AsRef e AsMut

std::convert::AsRef e std::convert::AsMut sono usati per convertire a buon mercato tipi di riferimenti. Per i tipi A e B ,

impl AsRef<B> for A

indica che a &A può essere convertito in un &B e,

impl AsMut<B> for A

indica che a &mut A possono essere convertiti in un &mut B

Questo è utile per eseguire conversioni di tipo senza copiare o spostare valori. Un esempio nella libreria standard è std::fs::File.open() :

fn open<P: AsRef<Path>>(path: P) -> Result<File>

Ciò consente a File.open() di accettare non solo Path , ma anche OsStr , OsString , str , String e PathBuf con conversione implicita poiché tutti questi tipi implementano AsRef<Path> .

Borrow, BorrowMut e ToOwned

I tratti di std::borrow::Borrow e std::borrow::BorrowMut sono usati per trattare i tipi presi in prestito come i tipi di proprietà. Per i tipi A e B ,

impl Borrow<B> for A

indica che una A presa in prestito può essere usata dove si desidera una B Ad esempio, std::collections::HashMap.get() usa Borrow per il suo metodo get() , consentendo a una HashMap con le chiavi di A di essere indicizzata con un &B

D'altra parte, std::borrow::ToOwned implementa la relazione inversa.

Pertanto, con i tipi A e B sopra menzionati, è possibile implementare:

impl ToOwned for B

Nota: mentre A può implementare Borrow<T> per più tipi distinti T , B può implementare ToOwned solo una volta.

Deref & DerefMut

I tratti std::ops::Deref e std::ops::DerefMut vengono utilizzati per sovraccaricare l'operatore di dereferenziazione, *x . Per i tipi A e B ,

impl Deref<Target=B> for A

indica che il dereferenziamento di un'associazione di &A produrrà un &B e,

impl DerefMut for A

indica che il dereferenziamento di un legame di &mut A produrrà un &mut B

Deref (resp. DerefMut ) fornisce anche una funzionalità linguistica utile chiamata deref coercion , che consente a &A (resp. &mut A ) di forzare automaticamente a un &B (resp. &mut B ). Questo è comunemente usato durante la conversione da String a &str , dato che &String è implicitamente obbligato a &str se necessario.

Nota: DerefMut non supporta la specifica del tipo risultante, utilizza lo stesso tipo di Deref .

Nota: a causa dell'uso di un tipo associato (diversamente da AsRef ), un determinato tipo può implementare al massimo una sola volta ciascuna di Deref e DerefMut .