std​::mem

Functions

align_ofalign_of_valcopy_lifetimecopy_mut_lifetimedropforgetfrom_be16from_be32from_be64from_le16from_le32from_le64initmin_align_ofmin_align_of_valmove_val_initnonzero_size_ofnonzero_size_of_valoverwritepref_align_ofpref_align_of_valreplacesize_ofsize_of_valswapto_be16to_be32to_be64to_le16to_le32to_le64transmutetransmute_copyuninituninitializedzeroed

Function std::mem::replaceStable[src]

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

Replace the value at a mutable location with a new one, returning the old value, without deinitialising or copying either one.

This is primarily used for transferring and swapping ownership of a value in a mutable location. For example, this function allows consumption of one field of a struct by replacing it with another value. The normal approach doesn't always work:

fn main() { struct Buffer<T> { buf: Vec<T> } impl<T> Buffer<T> { fn get_and_reset(&mut self) -> Vec<T> { // error: cannot move out of dereference of `&mut`-pointer let buf = self.buf; self.buf = Vec::new(); buf } } }
struct Buffer<T> { buf: Vec<T> }

impl<T> Buffer<T> {
    fn get_and_reset(&mut self) -> Vec<T> {
        // error: cannot move out of dereference of `&mut`-pointer
        let buf = self.buf;
        self.buf = Vec::new();
        buf
    }
}

Note that T does not necessarily implement Clone, so it can't even clone and reset self.buf. But replace can be used to disassociate the original value of self.buf from self, allowing it to be returned:

fn main() { struct Buffer<T> { buf: Vec<T> } impl<T> Buffer<T> { fn get_and_reset(&mut self) -> Vec<T> { use std::mem::replace; replace(&mut self.buf, Vec::new()) } } }
impl<T> Buffer<T> {
    fn get_and_reset(&mut self) -> Vec<T> {
        use std::mem::replace;
        replace(&mut self.buf, Vec::new())
    }
}