Transform owned collections in place

When you have a mutable reference to a collection like a Vec, you often encounter situations where you need to perform operations that require ownership of the data. Standard library methods like sort() and dedup() work on mutable references, but other transformations might require consuming the vector or reallocating it in a way that &mut Vec<T> does not easily permit without std::mem::replace.

The take_mut::take function solves this by allowing you to temporarily move the value out of the mutable reference, transform it as an owned object, and then place the result back into the original reference.

In-Place Sorting and Deduplication

A common scenario involves cleaning up a list of items. While Vec provides sort and dedup methods that work on &mut self, using take_mut::take allows you to treat the vector as a fully owned value within a closure. This is particularly useful when the transformation logic is complex or when you want to ensure the vector is returned to the reference only after all operations are complete.

use take_mut::take;

fn main() {
    let mut v = vec![1, 3, 2, 3, 1, 4];

    // Use take to gain ownership of the Vec inside the closure
    take(&mut v, |mut v| {
        v.sort();
        v.dedup();
        v // Return the owned, modified Vec to be put back into the reference
    });

    assert_eq!(v, vec![1, 2, 3, 4]);
}

Internally, take_mut::take uses std::ptr::read to move the value out of the mut_ref: &mut T. It then executes your closure, which must return a new value of the same type T. Finally, it uses std::ptr::write to restore the value to the original memory location.

Reversing and Extending Collections

You might also need to perform a sequence of operations that change the order and size of a collection. By taking ownership, you can use methods that consume the collection or require specific ownership semantics before returning the final version to the caller.

use take_mut::take;

fn main() {
    let mut v = vec![10, 20, 30];

    // Take ownership to reverse the order and append new elements
    take(&mut v, |mut v| {
        v.reverse();
        v.extend(vec![40, 50]);
        v
    });

    assert_eq!(v, vec![30, 20, 10, 40, 50]);
}

Because take_mut::take leaves the memory location temporarily uninitialized, it is designed to protect memory safety. If the closure panics, the function will exit the entire process rather than allowing the program to continue with an invalid reference. This ensures that the &mut T never points to "garbage" data if the transformation fails.