Rust
Konverteringsdrag

Anmärkningar

Från

Rust's From drag är ett allmänt drag för konvertering mellan typer. För alla två typer TypeA och TypeB ,

impl From<TypeA> for TypeB

indikerar att en instans av TypeB garanteras vara konstruerbar från en instans av TypeA . En implementering av From ser ut så här:

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 och std::convert::AsMut används för att billigt konvertera typer till referenser. För typerna A och B ,

impl AsRef<B> for A

indikerar att a &A kan konverteras till a &B och,

impl AsMut<B> for A

indikerar att en &mut A kan konverteras till en &mut B

Detta är användbart för att utföra typkonverteringar utan att kopiera eller flytta värden. Ett exempel i standardbiblioteket är std::fs::File.open() :

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

Detta tillåter File.open() att acceptera inte bara Path , utan också OsStr , OsString , str , String och PathBuf med implicit konvertering eftersom alla dessa implementerar AsRef<Path> .

Låna, låna Mut och ToOwned

std::borrow::Borrow och std::borrow::BorrowMut drag används för att behandla lånade typer som ägda typer. För typerna A och B ,

impl Borrow<B> for A

indikerar att ett lånat A kan användas där en B är önskad. std::collections::HashMap.get() använder till exempel Borrow för sin get() -metod, vilket gör att en HashMap med nycklar av A kan indexeras med a &B

Å andra sidan implementerar std::borrow::ToOwned det omvända förhållandet.

Således kan man med de ovannämnda typerna A och B implementera:

impl ToOwned for B

Obs: medan A kan implementera Borrow<T> för flera olika typer T , kan B bara implementera ToOwned gång.

Deref & DerefMut

std::ops::Deref och std::ops::DerefMut drag används för överbelastning av dereferensoperatören, *x . För typerna A och B ,

impl Deref<Target=B> for A

indikerar att dereferencing av en bindning av &A ger en &B och,

impl DerefMut for A

indikerar att dereferencing av en bindning av &mut A kommer att ge en &mut B

Deref (resp. DerefMut ) tillhandahåller också en användbar språkfunktion som kallas deref-tvång , som gör att en &A (resp. &mut A ) automatiskt tvingas till en &B (resp. &mut B ). Detta används vanligtvis vid konvertering från String till &str , eftersom &String implicit tvingas till &str vid behov.

Obs: DerefMut stöder inte att specificera den resulterande typen, den använder samma typ som Deref gör.

Obs: På grund av användningen av en tillhörande typ (till skillnad från i AsRef ) kan en given typ endast implementera var och en av Deref och DerefMut på en gång.