What is going on in move_semantics1?

[tal-zvon]

Seems like there's a lot going on, and as a beginner, although I've read the majority of the Rust book, I'm a bit confused.

First, a new immutable vector is declared - vec0.
Then on the next line, you pass ownership of vec0 to the fill_vec function. Simple enough.

Inside fill_vec, you somehow try to convert the original immutable vector into a mutable one? Sure, you have ownership, but is that even possible? Can you convert an immutable variable into a mutable one after it's been declared?

Or is it just declaring a completely new vec variable inside the fill_vec function that happens to have the same name (shadows) the original, and sets its value to the value of the original (a blank vector), thereby cloning it in the heap? I guess since the function now owns the original, as soon as the function returns, it gets dropped (or is it dropped as soon as it gets shadowed?), and the memory gets de-allocated, leaving only the new vector that is returned by the function?

Am I close?

[fraterenz]

related to #631

[pkazmier]

I had a similar question about the hint in this exercise. It states:

So vec0 is being moved into the function fill_vec when we call it on line 10, which means it gets dropped at the end of fill_vec, which means we can't use vec0 again on line 13

Here is the function in question:

fn fill_vec(vec: Vec<i32>) -> Vec<i32> {
    let mut vec = vec;

    vec.push(22);
    vec.push(44);
    vec.push(66);

    vec
}

Does it really get dropped at the end of the function? I was under the impression that ownership is transferred on assignment, so isn't it transferred to the shadow variable on the first line of the body? And then at the end of the function, isn't ownership transferred out?

I'm confused by the hint stating it is dropped at the end of the function.

[mo8it]

This hint is wrong. It was corrected at some point. So you are right, the vector is not dropped.

[mo8it]

let mut vec = vec uses shadowing. It doesn't clone anything on the heap. Here is an example that demonstrates this better:

let v1 = vec![1, 2];
let mut v2 = v1;
v2.push(3);
dbg!(v2);

This outputs v2 as [1, 2, 3]. But the important thing here is that v1 can't be accessed anymore. It was moved to v2, not cloned. So the following snippet won't compile:

let v1 = vec![1, 2];
let mut v2 = v1;
dbg!(v1); // Compiler error because v1 is moved to v2. 
v2.push(3);
dbg!(v2);

Now, if we change the two variable names to be the same:

let v = vec![1, 2];
let mut v = v;
v.push(3);
dbg!(v);

This code works too, but this time with shadowing.

If you own a value, you can also mutate it.