mem::take Moves a Value Out and Leaves a Default

A method with &mut self can change a field, but returning a field’s owned value directly can fail: the method would leave that field without a value. std::mem::take solves this for fields whose types implement Default. It replaces the field with a default value and returns the old value. Its signature asks for &mut T and returns T. It has a T: Default bound and no Clone bound.

Move a collection out of a field

Suppose an outbox holds messages until a caller is ready to process them. The caller needs ownership of the whole batch, while the outbox needs to remain usable. The standard library’s example uses take to return a vector from a mutable field and leave an empty vector behind. The same pattern works here:

struct Outbox {
    pending: Vec<String>,
}

impl Outbox {
    fn drain(&mut self) -> Vec<String> {
        std::mem::take(&mut self.pending)
    }
}

fn main() {
    let mut outbox = Outbox {
        pending: vec![String::from("ready")],
    };

    let batch = outbox.drain();
    assert_eq!(batch, vec![String::from("ready")]);
    assert!(outbox.pending.is_empty());

    outbox.pending.push(String::from("next"));
    assert_eq!(outbox.pending.len(), 1);
}

The returned batch owns the original vector. The outbox holds a new default vector, so it can accept another message. There is no call to clone in the method, and take does not require one. The value in the field changes even though the method never assigns to it explicitly: replacement is the operation that take performs. After the call, any code that reads pending sees the default vector, not the old batch.

Default decides what remains

Default is part of the method’s contract. The trait defines a default() method that returns a useful default value for a type. mem::take(&mut field) uses that value as the field’s replacement. For the vector example, the result is an empty vector, as the take documentation demonstrates.

That replacement should make sense for the surrounding struct. An empty pending list is useful because an outbox may have no messages. For another field, its type’s default might be valid Rust yet unsuitable for the state the struct is meant to represent. Read the field’s meaning before using take. If the replacement would make later methods misleading or invalid, choose a different representation or supply a deliberate replacement.

A custom field type must implement Default before it can be passed directly to mem::take. The trait documentation shows both an implementation of default() and #[derive(Default)]. Deriving works when the type’s fields implement Default. Either route makes the chosen default available wherever the type is used, so it deserves a meaningful value rather than one selected only to satisfy this call.

Option can represent an empty slot

Some values have no sensible default of their own. A job, for example, may require a command and should never exist as an empty job. A field of type Option<Job> can represent either a present job or an empty slot. Option::take moves the option’s current value out and leaves None in its place:

struct Job {
    command: String,
}

struct Runner {
    current: Option<Job>,
}

impl Runner {
    fn finish(&mut self) -> Option<Job> {
        self.current.take()
    }
}

Job has no Default implementation here. The method returns Some(job) when a job was present and None when the slot was already empty. In both cases, the field ends as None, matching the behavior shown in the Option::take examples. The return type also makes the empty case visible to the caller. Use this shape when absence is a real state that callers should handle.

Supply a replacement when the default is wrong

Sometimes a field must keep a specific value after the old one moves out. std::mem::replace takes both &mut T and a new T. It puts the supplied value in the field and returns the previous value. Its signature has no Default bound. For an outbox that should start its next batch with a marker, the operation could be std::mem::replace(&mut self.pending, vec![String::from("start")]).

That choice changes what future reads of the field observe. With take, they see the type’s default. With replace, they see the value supplied by the caller. The documentation for both functions describes that distinction. Select the replacement according to the state the object must have immediately after the move.

What to do

1. Identify the field whose owned value the caller needs. Check what state its owner must hold after the call.
2. If the field’s Default value is suitable, return std::mem::take(&mut self.field). Confirm that the field’s type implements Default.
3. If absence is meaningful, consider Option<T> and call Option::take. Handle the returned None case.
4. If the field needs a particular new value, pass it to std::mem::replace. Check both the returned old value and the field’s state after the call.