Chapter review: Values

It does not compile: E0384. A name made with plain let is set once. Line 4 tries to give quiet a second value, so the compiler refuses with E0384, "cannot assign twice to immutable variable", and its help line suggests let mut quiet. Lesson 2.2 is the one to revisit.

error[E0384]: cannot assign twice to immutable variable `quiet`
 --> src/main.rs:4:5
  |
2 |     let quiet = false;
  |         ----- first assignment to `quiet`
3 |     println!("quiet: {}", quiet);
4 |     quiet = true;
  |     ^^^^^^^^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut quiet = false;
  |         +++

The program prints: 9 push_str adds , café to the end, so the String holds ok, café: eight letters, counting the comma and the space. But len() counts bytes, and the accented é takes two, so the answer is 9. Lesson 2.5 has both halves of this.

The program prints: about 5 bytes each Both numbers are whole numbers, so the answer is a whole number too. 23 divided by 4 is 5 with 3 left over, and the leftover is dropped, not rounded up. To keep the fraction you need decimal numbers such as f64 (lesson 2.3).

It does not compile: E0308. The type says a pair, (u32, u32), and the value has three parts. A tuple always has exactly as many parts as its type says, so this is a value of the wrong type: E0308, "expected a tuple with 2 elements, found one with 3 elements". Lesson 2.6 covers tuples.

error[E0308]: mismatched types
 --> src/main.rs:1:29
  |
1 | const VERSION: (u32, u32) = (0, 2, 1);
  |                ----------   ^^^^^^^^^ expected a tuple with 2 elements, found one with 3 elements
  |                |
  |                expected because of the type of the constant
  |
  = note: expected tuple `(u32, u32)`
             found tuple `(u32, u32, {integer})`

It compiles, then panics at run time. It compiles, because mut allows the change. The first subtraction takes unread to 0, the smallest u8; the second asks for minus one, which a u type has no pattern for. The program stops with attempt to subtract with overflow: the edge at the bottom works just like the one at the top (lesson 2.4).

The program prints: 50 Each let makes a brand new name that hides the one before, so no mut is needed. The second is the length of hello, 5 bytes, a number now and not text; the third is that times 10. Shadowing can even change the type, which mut cannot (lesson 2.2).

The program prints: Sam has sent 4 Destructuring matches by position: name takes the first part, "Sam", and sent the second, 3. The second hole is filled with sent + 1, which is worked out first, so it prints 4. The tuple itself still holds 3 (lesson 2.6).

The program prints: true false The first hole asks "at most the limit?", and 200 is, so true. The second asks "not quiet and under the limit?": not quiet is true, but 200 is not less than 200, and one false side makes && false. The difference between < and <= is the whole question (lesson 2.3).