Chapter review: Collections

The program prints: only 2 messages Positions count from 0, so a two-item list has positions 0 and 1, and 2 is past the end. get never crashes: it answers None, and the None arm runs. history[2] would have panicked instead. Lesson 6.1.

It does not compile: E0502. The closure captures history by borrowing it to look, and that borrow lasts until its last call, on the final line. push needs an exclusive borrow in the middle of that stretch, so the compiler refuses. Call count() before the push, or make the closure after it. Lesson 6.4, with the rule from lesson 4.4.

error[E0502]: cannot borrow `history` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let count = || history.len();
  |                 -- ------- first borrow occurs due to use of `history` in closure
  |                 |
  |                 immutable borrow occurs here
4 |     history.push(String::from("hello"));
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("{}", count());
  |                    ----- immutable borrow later used here

The program prints: 2 Some(3) Every word is lowercased before it becomes a key, so the three greetings land in one row and bye in another: two rows. entry(…).or_insert(0) makes the row at 0 the first time and the += 1 adds to it every time, so that row reaches 3. Lesson 6.3.

It does not compile: E0596. iter() lends each message to look at, and push wants to change it, which a looking borrow cannot do. The walk that lends each item to change is iter_mut() (or &mut history). Making history itself mut is not enough: the kind of walk decides. Lesson 6.5 has the table of all three walks.

error[E0596]: cannot borrow `*m` as mutable, as it is behind a `&` reference
 --> src/main.rs:4:9
  |
3 |     for m in history.iter() {
  |              -------------- this iterator yields `&` references
4 |         m.push('!');
  |         ^ `m` is a `&` reference, so it cannot be borrowed as mutable
  |
help: use mutable method
  |
3 |     for m in history.iter_mut() {
  |                          ++++

The program prints: 1 enumerate numbers from 0, so "ok" is 0 and "sure thing", the first one longer than 3 bytes, is 1. break leaves the loop right there, so "absolutely" is never looked at. If you said 2, you counted from 1: lesson 6.2.

The program prints: ["jo", "sam", "ada", "alexandra"] The closure hands sort_by_key each name's length, and it sorts by that, shortest first. "sam" and "ada" both have 3 letters, and items with equal keys keep the order they had, so "sam" stays in front. It is not alphabetical: only the length was compared. Lesson 6.4.

It does not compile: E0283. sum(), like collect(), can build more than one type, and nothing here says which: total has no type. The compiler stops with "type annotations needed" and even suggests let total: usize. Lesson 6.5 met the same error on collect().

error[E0283]: type annotations needed
 --> src/main.rs:3:9
  |
3 |     let total = history.iter().map(|m| m.len()).sum();
  |         ^^^^^                                   --- type must be known at this point
  |
  = note: the type must implement `Sum<usize>`
help: the trait `Sum` is implemented for `usize`
 --> /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/accum.rs:50:8
 ::: /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/accum.rs:206:0
  |
  = note: in this macro invocation
note: required by a bound in `std::iter::Iterator::sum`
 --> /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/core/src/iter/traits/iterator.rs:3665:4
  = note: this error originates in the macro `integer_sum_product` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider giving `total` an explicit type, where the type for type parameter `S` is specified
  |
3 |     let total: usize = history.iter().map(|m| m.len()).sum();
  |              +++++++

The program prints: HELLO HOWDY Each item goes through every step in order: filter drops "hi" and "hey", map capitalises what is left, and take(2) stops after two, so "hiya there" is never even looked at. collect() knows to build a Vec<String> from the type on loud. Lesson 6.5.