Wie wird eine veränderbare Referenz auf einen nicht kopierbaren Typ aktualisiert?

Question

Ich möchte

impl Widget { 
    fn foo(self, rhs: Widget) -> Self { 
     // Some stuff 
    } 

    fn update(&mut self, rhs: Widget) { 
     *self = (*self).foo(rhs) 
    } 
} 

so etwas wie

tun, aber der Compiler beschwert sich „nicht aus geliehenen Kontext bewegen.“ Was ist der richtige Weg, dies zu tun?

Answer 1

Eine Möglichkeit ist es, die take_mut Kiste zu verwenden, die die take Funktionen bietet, die genau tun, was Sie wollen:

take ermöglicht T aus einem &mut T nehmen, etwas zu tun, damit deren Verbrauch einschließlich und Herstellung eines anderen T, um in die &mut T zurück zu setzen.

Wie Francis Gagné darauf, das Problem dabei ist, dass die &mut Referenz in einem ungültigen Zustand sein wird, wenn eine Panik geschieht, und dies kann zu undefiniertem Verhalten führen kann. Der take_mut Ansatz ist:

Während take, wenn eine Panik auftritt, wird der gesamte Prozess beendet werden, da es keine gültigen T ist zurück in die &mut T zu setzen.

Hier wird der Code mit take:

extern crate take_mut; 

struct Widget; 

impl Widget { 
    fn foo(self, rhs: Widget) -> Self { 
     self 
    } 

    fn update(&mut self, rhs: Widget) { 
     take_mut::take(self, |s| s.foo(rhs)); 
    } 
} 

Answer 2

Machen Sie es anders herum:

impl Widget { 
    fn op(mut self, rhs: Widget) -> Self { 
     self.update(rhs); 
     self 
    } 

    fn update(&mut self, rhs: Widget) { 
     // Some stuff 
    } 
} 

Sie können nicht aus einem geliehenen Zeiger bewegen, weil das Bewegen der Quelle unbrauchbar macht, aber da Sie die Quelle nicht tun besitzen, würden diese Informationen haben, propagieren zurück zum Besitzer, und Rust unterstützt das nicht.

Sie könnten sagen "aber ich gebe *self einen neuen Wert, bevor die Funktion zurückgibt!". Das Problem dabei ist, dass *self, wenn zwischen dem Verschieben und der Zuweisung eine Panik herrscht, immer noch kein gültiger Wert übrig wäre. Dies ist besonders problematisch, wenn das Fallenlassen von self kein No-Op ist (obwohl es Rust egal ist, ob das Fallenlassen ein No-Op ist oder nicht).