Come posso riutilizzare una casella di cui ho rimosso il valore?

Question

ho qualche tipo non copiabile e una funzione che consuma e (forse) lo produce:

type Foo = Vec<u8>; 

fn quux(_: Foo) -> Option<Foo> { 
    Some(Vec::new()) 
} 

Consideriamo ora un tipo che è in qualche modo concettualmente molto simile a Box:

struct NotBox<T> { 
    contents: T 
} 

Possiamo scrivere una funzione che sposta temporaneamente il contenuto dello NotBox e rimette qualcosa prima di restituirlo:

fn bar(mut notbox: NotBox<Foo>) -> Option<NotBox<Foo>> { 
    let foo = notbox.contents; // now `notbox` is "empty" 
    match quux(foo) { 
     Some(new_foo) => { 
      notbox.contents = new_foo; // we put something back in 
      Some(notbox) 
     } 
     None => None 
    } 
} 

Voglio scrivere una funzione analoga che funziona con Box es ma il compilatore non piace:

fn baz(mut abox: Box<Foo>) -> Option<Box<Foo>> { 
    let foo = *abox; // now `abox` is "empty" 
    match quux(foo) { 
     Some(new_foo) => { 
      *abox = new_foo; // error: use of moved value: `abox` 
      Some(abox) 
     } 
     None => None 
    } 
} 

potevo tornare Some(Box::new(new_foo)) invece, ma che esegue l'allocazione inutile - ho già qualche ricordo a mia disposizione! È possibile evitarlo?

Vorrei anche per sbarazzarsi dei match dichiarazioni ma ancora una volta il compilatore non è soddisfatto (anche per la versione NotBox):

fn bar(mut notbox: NotBox<Foo>) -> Option<NotBox<Foo>> { 
    let foo = notbox.contents; 
    quux(foo).map(|new_foo| { 
     notbox.contents = new_foo; // error: capture of partially moved value: `notbox` 
     notbox 
    }) 
} 

E 'possibile ovviare a questo?

Answer 1

Quindi, uscire da un Box è un caso speciale ... e adesso?

Il modulo presenta una serie di funzioni sicure per spostare i valori intorno, senza creare fori (!) Nella memoria di sicurezza di Rust.Di interesse qui sono swap e replace:

pub fn replace<T>(dest: &mut T, src: T) -> T 

che possiamo usare in questo modo:

fn baz(mut abox: Box<Foo>) -> Option<Box<Foo>> { 
    let foo = std::mem::replace(&mut *abox, Foo::default()); 

    match quux(foo) { 
     Some(new_foo) => { 
      *abox = new_foo; 
      Some(abox) 
     } 
     None => None 
    } 
} 

Aiuta anche nel caso map, perché non prendere in prestito il Box:

fn baz(mut abox: Box<Foo>) -> Option<Box<Foo>> { 
    let foo = std::mem::replace(&mut *abox, Foo::default()); 

    quux(foo).map(|new_foo| { *abox = new_foo; abox }) 
} 

Answer 2

Lo spostamento delle caselle è speciale nel compilatore. Puoi spostare qualcosa da loro, ma non puoi spostare qualcosa indietro, perché anche l'atto di uscire viene rilasciato. È possibile fare qualcosa di sciocco con std::ptr::write, std::ptr::read e std::ptr::replace, ma è difficile farlo bene, perché qualcosa di valido deve essere all'interno di uno Box quando viene rilasciato. Suggerirei semplicemente di accettare l'allocazione o passare a un valore Box<Option<Foo>>.

Answer 3

Siamo in grado di scrivere una funzione che sposta temporaneamente fuori i contenuti del NotBox e mette qualcosa di nuovo in prima di tornare

Ecco perché si può parzialmente uscire dalla struct che si prende per valore. Si comporta come se tutti i campi fossero variabili separate. Ciò non è però possibile se la struct implementa Drop, perché drop richiede che l'intera struttura sia valida, sempre (in caso di panico).

Per quanto riguarda la soluzione alternativa, non sono state fornite informazioni sufficienti, in particolare, perché baz deve prendere come argomento Box e perché non è possibile utilizzare quux? Quali funzioni sono tue e quali fanno parte di un'API che non puoi modificare? Qual è il vero tipo di Foo? È grande?

La soluzione migliore sarebbe non utilizzare affatto Box.