Transform owned strings in place

To replace an owned String in-place with a transformed version, you can use the take_mut::take function. This is useful for operations that require ownership of the string, such as concatenation. The function takes a mutable reference and a closure. The closure receives the owned value, and its return value is put back into the reference.

For example, you can append text to a String. The closure takes the original String by value, consumes it, and returns a new String that replaces the original one.

fn main() {
    use take_mut::take;
    let mut s = String::from("Hello");
    take(&mut s, |s| {
        s + ", world!"
    });
    assert_eq!(s, "Hello, world!");
}

The take function enables any transformation that consumes the original value and returns a new one of the same type. You can perform more complex modifications within the closure, such as changing the case of the string. The new value can have a different length and capacity.

fn main() {
    use take_mut::take;
    let mut message = String::from("owned");
    take(&mut message, |s| {
        s.to_uppercase()
    });
    assert_eq!(message, "OWNED");
    assert_eq!(message.len(), 5);
}

If the closure panics, the process will abort. This ensures that the mutable reference is not left in an uninitialized state.