Functions take ownership too

fn describe(v: Vec<i32>) -> String {
    format!("{} items", v.len())
}

fn main() {
    let data = vec![10, 20, 30];
    let msg = describe(data);   // data MOVED into describe

    // println!("{data:?}");    // <- E0382: value borrowed after move
    //                          // (describe owns it now, then frees it)

    println!("{msg}");
}

fn measure(v: Vec<i32>) -> (Vec<i32>, i32) {
    let sum: i32 = v.iter().sum(); // .iter() borrows, doesn't move
    (v, sum)                       // hand v back alongside the answer
}

fn main() {
    let data = vec![1, 2, 3, 4];
    let (data, total) = measure(data); // rebind the returned owner

    // data is ours again because measure RETURNED it:
    println!("sum {total}, and still have {} items", data.len());
}

fn grow(mut v: Vec<i32>, x: i32) -> Vec<i32> {
    v.push(x);   // mutate the value we own
    v            // move it back out
}

fn main() {
    // each call takes ownership and returns it, so the next call can take it:
    let v = grow(grow(grow(Vec::new(), 1), 2), 3);
    println!("{v:?}"); // [1, 2, 3]

    // the same handle, threaded through three owners in turn:
    let same = grow(v, 4);
    println!("{same:?}");
}