Chapter review: Memory

It does not compile: E0382. The first turn of the loop moves the key from said to last. The second turn tries to move it again, but said owns nothing any more, so the compiler reports E0382 and says the value was moved "in previous iteration of loop". A plain = moves a String exactly like passing it to a function. Revisit lesson 4.3.

error[E0382]: use of moved value: `said`
 --> src/main.rs:5:16
  |
2 |     let said = String::from("hello");
  |         ---- move occurs because `said` has type `String`, which does not implement the `Copy` trait
3 |     let mut last = String::new();
4 |     for _ in [1, 2] {
  |     --------------- inside of this loop
5 |         last = said;
  |                ^^^^ value moved here, in previous iteration of loop
  |
help: consider cloning the value if the performance cost is acceptable
  |
5 |         last = said.clone();
  |                    ++++++++

The program prints: 10 16 The slice covers the first 10 bytes, Chatterbox, so its len() is 10. Every &str is 16 bytes in the frame, a pointer and a length, however much text it looks at; 24 would be a String, which also carries a capacity. Revisit lesson 4.1 for the sizes and lesson 4.6 for the slice.

It does not compile: E0502. A slice is a borrow, and first is used on the last line, so its loan is still out when push_str wants to change history. Growing the String might move its text to a bigger block and leave the slice pointing at the old one, so the compiler reports E0502. Print first before the push and it compiles. Revisit lesson 4.4 and lesson 4.6.

error[E0502]: cannot borrow `history` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &history[..7];
  |                  ------- immutable borrow occurs here
4 |     history.push_str("you: again\n");
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |                ----- immutable borrow later used here

The program prints: 4 5 A u32 is Copy: its 4 bytes are the whole value, so bump receives its own duplicate. Changing that duplicate leaves messages_seen at 4, and the returned 5 lands in next. Nothing moved, so both names still work. Revisit lesson 4.3, "Why numbers do not move".

It does not compile: E0596. push_str needs an editing loan of the String, and an editing loan can only be made from a value its owner allows to change. history was made without mut, so the compiler reports E0596, cannot borrow as mutable. E0384 would be assigning a new value with =; this is a change through a method. Revisit lesson 4.5.

error[E0596]: cannot borrow `history` as mutable, as it is not declared as mutable
 --> src/main.rs:3:5
  |
3 |     history.push_str("you: hi\n");
  |     ^^^^^^^ cannot borrow as mutable
  |
help: consider changing this to be mutable
  |
2 |     let mut history = String::new();
  |         +++

The program prints: hi hi! .clone() makes a second String with its own heap block and its own key, so last and said share nothing. Adding to last changes only its block. That independence is exactly what a clone costs you a copy for. Revisit lesson 4.3.

It compiles and runs. A borrow lasts from where it is made to its last use, not to the end of the block. cmd is last used on line 4, so by the time clear changes line the loan is over, and the program prints /say and then []. Compare it with the history question above: same shape, different order. Revisit lesson 4.4.

It does not compile: E0499. Both arguments are editing loans of the same transcript, and both are alive for the whole call. Two &mut at once is E0499: inside the function, clearing one would empty the other while it was being copied. E0502 is for an editor meeting a reader. Revisit lesson 4.5.

error[E0499]: cannot borrow `transcript` as mutable more than once at a time
 --> src/main.rs:8:32
  |
8 |     copy_into(&mut transcript, &mut transcript);
  |     --------- ---------------  ^^^^^^^^^^^^^^^ second mutable borrow occurs here
  |     |         |
  |     |         first mutable borrow occurs here
  |     first borrow later used by call