Chapter review: Shapes

The program prints: hello! (edited 2 times) edit takes &mut self, so it changes the message where it lives: each call replaces the text and adds one to edits. label only looks with &self and sees the result of both edits. If the change seemed to vanish, reopen lesson 5.2.

It does not compile: E0382. A struct owns its fields, and a single field can be handed over on its own: archive(said.text) moves the text out. Printing said.author afterwards would be fine, but said.text is gone, so the compiler refuses with the moved-value error. Lesson 5.1 shows a field moving out; lesson 4.3 is the rule behind it.

error[E0382]: borrow of moved value: `said.text`
  --> src/main.rs:16:37
   |
15 |     archive(said.text);
   |             --------- value moved here
16 |     println!("{}: {}", said.author, said.text);
   |                                     ^^^^^^^^^ value borrowed here after move
   |
   = note: move occurs because `said.text` has type `String`, which does not implement the `Copy` trait

The program prints: talking to myself? / hi, whoever you are A pattern can look inside an Option: Some("bot") fits only a Some holding exactly that text, and arms are tried from the top, so it wins before Some(n) gets a turn. None has its own arm with its own answer. Lessons 5.4 and 5.5 cover both halves.

The program prints: [HI][] Each variant carries its own data, or none: Shout carries "hi", which its arm names t and capitalises, and Silent carries nothing and gives back an empty String. A variant's name is never printed unless you print it. Reopen lesson 5.3 if the brackets surprised you.

It does not compile: E0004. The program never calls it with 2, but the compiler does not care what you happen to pass: a match must cover every value its input could have. Some(2) and every bigger number have no arm, so it refuses with E0004 and names the missing range. An arm like Some(n) => … fixes it; see lesson 5.5.

error[E0004]: non-exhaustive patterns: `Some(2_u32..=u32::MAX)` not covered
 --> src/main.rs:2:11
  |
2 |     match unread {
  |           ^^^^^^ pattern `Some(2_u32..=u32::MAX)` not covered
  |
note: `Option<u32>` defined here
 --> /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:598:0
 ::: /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/option.rs:606:4
  |
  = note: not covered
  = note: the matched value is of type `Option<u32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
5 ~         Some(1) => String::from("1 new message"),
6 ~         Some(2_u32..=u32::MAX) => todo!(),
  |

It does not compile: E0596. show only borrowed the message to look at it (&Message), but shout asks for &mut self, a borrow that may change it. You cannot get a changing borrow out of a looking one, even though main passed &mut m: the signature of show is what counts. Lesson 5.2 explains what each kind of self promises.

error[E0596]: cannot borrow `*m` as mutable, as it is behind a `&` reference
  --> src/main.rs:12:5
   |
12 |     m.shout();
   |     ^ `m` is a `&` reference, so it cannot be borrowed as mutable
   |
help: consider changing this to be a mutable reference
   |
11 | fn show(m: &mut Message) {
   |             +++

The program prints: quiet robot Arms are tried from the top. a has 0 likes, so the first arm fits before its author is ever checked. b skips the first arm, and the second takes its author apart with .. skipping the rest; the guard asks whether it is "bot", it is, so "liked" never gets a turn. Lesson 5.5 has guards and ...

The program prints: Say(None) "/say" has no space, so find gives None, and the guard picks Command::Say(None). The if let wants a Say with text inside, which this is not, so the else prints the debug form that #[derive(Debug)] wrote for you. Lessons 5.4 and 5.5.