Chapter review: Decisions

It does not compile: E0308. An if that gives a value must give the same kind of value from every block, because label can only hold one kind. Here one road gives text and the other a number, so the compiler reports E0308, mismatched types. Revisit lesson 3.1, "if is an expression".

error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:3:52
  |
3 |     let label = if count == 1 { "message" } else { 2 };
  |                                 ---------          ^ expected `&str`, found integer
  |                                 |
  |                                 expected because of this

The program prints: 3 The empty message is skipped by continue and the loop goes on. hi, /help and yo are counted: this loop counts every non-empty line, commands included. At /quit, break leaves the loop, so late is never seen. Revisit lesson 3.3 for the difference between the two words.

The program prints: not a command A text pattern matches exactly, and "/quit\n" has one more character than "/quit": the newline from pressing Enter. So the catch-all takes it. Calling typed.trim() before the match fixes it. Revisit lesson 3.4, and lesson 3.2 for exact matching.

The program prints: too long An else if chain runs the first block whose question is true, from the top. WHAT? is 5 bytes, more than 4, so the length check wins and the question mark is never looked at. That is why Chatterbox's reply asks about length first. Revisit lesson 3.1.

It does not compile: E0384. A loop that counts down has to change its counter, and a name made with plain let can never change. The compiler reports E0384, cannot assign twice to an immutable variable, and suggests let mut. The loop in lesson 3.3 starts with let mut retries for exactly this reason (lesson 2.2 has the rule).

error[E0384]: cannot assign twice to immutable variable `retries`
 --> src/main.rs:5:9
  |
2 |     let retries = 3;
  |         ------- first assignment to `retries`
...
5 |         retries -= 1;
  |         ^^^^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut retries = 3;
  |         +++

The program prints: hi yo Like read_line, push_str adds to what is already there, so after two turns the String holds both lines. trim only removes whitespace at the two ends, so the newline in the middle stays and two lines are printed. That is why Chatterbox calls line.clear() at the top of every turn. Revisit lesson 3.4.

It does not compile: E0004. A match must have an arm for every possible value, and a bool has two. The compiler reports E0004, non-exhaustive patterns, and names the one you forgot: false. It does not matter that quiet happens to be false here; the check is about every value it could hold. Revisit lesson 3.2.

error[E0004]: non-exhaustive patterns: `false` not covered
 --> src/main.rs:3:11
  |
3 |     match quiet {
  |           ^^^^^ pattern `false` not covered
  |
  = note: the matched value is of type `bool`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
4 ~         true => println!("(quiet)"),
5 ~         false => todo!(),
  |