Rust ile öğreniyorum / deniyorum ve bu dilde bulduğum tüm zarafette, beni şaşırtan ve tamamen yersiz görünen bir tuhaflık var.
Rust, yöntem çağrıları yaparken işaretçileri otomatik olarak dereferences. Tam davranışı belirlemek için bazı testler yaptım:
struct X { val: i32 }
impl std::ops::Deref for X {
type Target = i32;
fn deref(&self) -> &i32 { &self.val }
}
trait M { fn m(self); }
impl M for i32 { fn m(self) { println!("i32::m()"); } }
impl M for X { fn m(self) { println!("X::m()"); } }
impl M for &X { fn m(self) { println!("&X::m()"); } }
impl M for &&X { fn m(self) { println!("&&X::m()"); } }
impl M for &&&X { fn m(self) { println!("&&&X::m()"); } }
trait RefM { fn refm(&self); }
impl RefM for i32 { fn refm(&self) { println!("i32::refm()"); } }
impl RefM for X { fn refm(&self) { println!("X::refm()"); } }
impl RefM for &X { fn refm(&self) { println!("&X::refm()"); } }
impl RefM for &&X { fn refm(&self) { println!("&&X::refm()"); } }
impl RefM for &&&X { fn refm(&self) { println!("&&&X::refm()"); } }
struct Y { val: i32 }
impl std::ops::Deref for Y {
type Target = i32;
fn deref(&self) -> &i32 { &self.val }
}
struct Z { val: Y }
impl std::ops::Deref for Z {
type Target = Y;
fn deref(&self) -> &Y { &self.val }
}
#[derive(Clone, Copy)]
struct A;
impl M for A { fn m(self) { println!("A::m()"); } }
impl M for &&&A { fn m(self) { println!("&&&A::m()"); } }
impl RefM for A { fn refm(&self) { println!("A::refm()"); } }
impl RefM for &&&A { fn refm(&self) { println!("&&&A::refm()"); } }
fn main() {
// I'll use @ to denote left side of the dot operator
(*X{val:42}).m(); // i32::m() , Self == @
X{val:42}.m(); // X::m() , Self == @
(&X{val:42}).m(); // &X::m() , Self == @
(&&X{val:42}).m(); // &&X::m() , Self == @
(&&&X{val:42}).m(); // &&&X:m() , Self == @
(&&&&X{val:42}).m(); // &&&X::m() , Self == *@
(&&&&&X{val:42}).m(); // &&&X::m() , Self == **@
println!("-------------------------");
(*X{val:42}).refm(); // i32::refm() , Self == @
X{val:42}.refm(); // X::refm() , Self == @
(&X{val:42}).refm(); // X::refm() , Self == *@
(&&X{val:42}).refm(); // &X::refm() , Self == *@
(&&&X{val:42}).refm(); // &&X::refm() , Self == *@
(&&&&X{val:42}).refm(); // &&&X::refm(), Self == *@
(&&&&&X{val:42}).refm(); // &&&X::refm(), Self == **@
println!("-------------------------");
Y{val:42}.refm(); // i32::refm() , Self == *@
Z{val:Y{val:42}}.refm(); // i32::refm() , Self == **@
println!("-------------------------");
A.m(); // A::m() , Self == @
// without the Copy trait, (&A).m() would be a compilation error:
// cannot move out of borrowed content
(&A).m(); // A::m() , Self == *@
(&&A).m(); // &&&A::m() , Self == &@
(&&&A).m(); // &&&A::m() , Self == @
A.refm(); // A::refm() , Self == @
(&A).refm(); // A::refm() , Self == *@
(&&A).refm(); // A::refm() , Self == **@
(&&&A).refm(); // &&&A::refm(), Self == @
}( Oyun Parkı )
Yani, öyle görünüyor ki, az çok:
- Derleyici, bir yöntemi çağırmak için gereken sayıda dereference operatörü ekleyecektir.
- Derleyici,
&self(çağrı yoluyla) kullanılarak bildirilen yöntemleri çözerken :- İlk denemek için tek bir başvuru
self - Ardından, tam olarak
self - Ardından, bir eşleşme için gereken sayıda dereference operatörü eklemeyi dener
- İlk denemek için tek bir başvuru
selfTür için (değere göre çağrı) kullanılarak bildirilen yöntemler , tür için (başvuruya göre çağrı)Tkullanılarak bildirilmiş gibi davranır ve nokta operatörünün sol tarafında ne varsa&selfbaşvuruyu çağırır&T.- Yukarıdaki kurallar ilk olarak ham yerleşik kayıt silme ile denenir ve eşleşme yoksa, özellikli aşırı yük
Derefkullanılır.
Tam otomatik kayıt silme kuralları nelerdir? Böyle bir tasarım kararı için herhangi bir resmi gerekçe verilebilir mi?
1
Bazı iyi cevaplar alma umuduyla bunu Rust altdizenine çapraz gönderdim !
—
Shepmaster
Ekstra eğlence için deneyi jenerik olarak tekrarlamaya çalışın ve sonuçları karşılaştırın.
—
user2665887