Transform owned collections in place

The take_mut::take function allows you to temporarily move a value out of a mutable reference, perform operations that require ownership, and then place a new value back into that reference. This is particularly useful for Vec transformations where standard methods like sort or dedup work on references, but other logic might require consuming the collection entirely before returning a modified version.

When you use take_mut::take, you provide a closure that receives the owned value. The function ensures that the memory location is correctly updated with the closure's return value. However, because the memory location is temporarily invalid while the closure runs, take_mut will exit the program if the closure panics to prevent undefined behavior.

Sorting and Deduplicating in Place

If you have a Vec containing duplicate or unsorted data, you can use take_mut::take to perform a sequence of transformations that require the vector to be mutable and owned within the scope of the operation.

use take_mut::take;

fn main() {
    let mut values = vec![3, 1, 4, 1, 5, 9, 2, 6, 5];

    take(&mut values, |mut v| {
        v.sort();
        v.dedup();
        v
    });

    assert_eq!(values, vec![1, 2, 3, 4, 5, 6, 9]);
}

Reversing and Extending Collections

In scenarios where you need to reverse a collection and then append new elements, take_mut::take provides a clean way to handle the transition from the original owned state to the modified state. This avoids the need for temporary variables or manual std::mem::replace calls with dummy values.

use take_mut::take;

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

    take(&mut values, |mut v| {
        v.reverse();
        v.extend_from_slice(&[4, 5, 6]);
        v
    });

    assert_eq!(values, vec![3, 2, 1, 4, 5, 6]);
}

Internally, take_mut::take uses std::ptr::read to move the value out of the mutable reference and std::ptr::write to restore it. This mechanism allows the closure to treat the value as fully owned, enabling any transformation that the type T supports.