Rust
Traits de conversion

Remarques

De

Le trait Rust's From est un trait général pour la conversion entre les types. Pour deux types TypeA et TypeB ,

impl From<TypeA> for TypeB

indique qu'une instance de TypeB est garantie d'être constructible à partir d'une instance de TypeA . Une implémentation de From ressemble à ceci:

struct TypeA {
    a: u32,
}

struct TypeB {
    b: u32,
}

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

AsRef & AsMut

std::convert::AsRef et std::convert::AsMut sont utilisés pour convertir les types en références à moindre coût. Pour les types A et B ,

impl AsRef<B> for A

indique que a &A peut être converti en a &B et,

impl AsMut<B> for A

indique que a &mut A peut être converti en &mut B

Ceci est utile pour effectuer des conversions de type sans copier ou déplacer des valeurs. Un exemple dans la bibliothèque standard est std::fs::File.open() :

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

Cela permet à File.open() d’accepter non seulement le Path , mais aussi OsStr , OsString , str , String et PathBuf avec une conversion implicite car ces types implémentent tous AsRef<Path> .

Emprunter, emprunterMut et ToOweded

Les traits std::borrow::BorrowMut std::borrow::Borrow et std::borrow::BorrowMut sont utilisés pour traiter les types empruntés comme les types possédés. Pour les types A et B ,

impl Borrow<B> for A

indique qu'un A emprunté peut être utilisé lorsqu'un B est souhaité. Par exemple, std::collections::HashMap.get() utilise Borrow pour sa méthode get() , permettant à HashMap avec les clés de A d'être indexées avec a &B

En revanche, std::borrow::ToOwned implémente la relation inverse.

Ainsi, avec les types susmentionnés A et B on peut implémenter:

impl ToOwned for B

Remarque: alors que A peut implémenter Borrow<T> pour plusieurs types distincts T , B ne peut implémenter que ToOwned une fois.

Deref & DerefMut

Les traits std::ops::Deref et std::ops::DerefMut sont utilisés pour surcharger l'opérateur de déréférencement, *x . Pour les types A et B ,

impl Deref<Target=B> for A

indique que le déréférencement d'une liaison de &A donnera un &B et,

impl DerefMut for A

indique que le déréférencement d'une liaison de &mut A donnera un &mut B

Deref (resp. DerefMut ) fournit également une fonction de langage utile appelée deref coercion , qui permet à a &A (resp. &mut A ) de forcer automatiquement a &B (resp. &mut B ). Ceci est couramment utilisé lors de la conversion de String en &str , as &String étant implicitement contraint à &str si nécessaire.

Remarque: DerefMut ne prend pas en charge la spécification du type résultant, il utilise le même type que Deref .

Remarque: En raison de l'utilisation d'un type associé (contrairement à AsRef ), un type donné ne peut implémenter que Deref et DerefMut au plus une fois.