Chapter review: the real model

The program prints: [{"author":"you","text":"hi"},{"author":"bot","text":"you said: hi"}] A Vec of things that can be written out can itself be written out, as a JSON list in square brackets with one record per message. The name history belongs to the program, not to the data, so it never shows up in the JSON. This is exactly what chatterbox.json holds (lesson 9.1).

It does not compile: E0308. It never gets as far as running. env::var returns a Result, because the setting may not be there, and a Result is not a String, so the compiler reports mismatched types. Lesson 9.2 handled it with map_err and ?; a match works too.

error[E0308]: mismatched types
 --> src/main.rs:4:23
  |
4 |     let key: String = env::var("CHATTERBOX_API_KEY");
  |              ------   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `String`, found `Result<String, VarError>`
  |              |
  |              expected due to this
  |
  = note: expected struct `String`
               found enum `Result<String, VarError>`
help: consider using `Result::expect` to unwrap the `Result<String, VarError>` value, panicking if the value is a `Result::Err`
  |
4 |     let key: String = env::var("CHATTERBOX_API_KEY").expect("REASON");
  |                                                     +++++++++++++++++

It compiles and runs. It runs and prints bot: Hi Sam!. serde quietly skips any field your struct does not name, which is why the structs in lesson 9.2 list only the path choices, message, content. Extra fields are fine; a missing one is not, as a later question shows.

It does not compile: E0433. #[cfg(test)] means "only build this for cargo test". In a normal build the whole tests module does not exist, so tests:: leads nowhere and the compiler cannot resolve the path. That is the point lesson 9.3 made: none of your tests ends up in the program you ship, so nothing outside them may lean on them.

error[E0433]: cannot find module or crate `tests` in this scope
 --> src/main.rs:2:20
  |
2 |     println!("{}", tests::sample_reply());
  |                    ^^^^^ use of unresolved module or unlinked crate `tests`
  |
  = help: you might be missing a crate named `tests`

It does not compile: E0277. Deserialize only promises "I can be read in". to_string accepts a value only if its type keeps the other promise, Serialize, so the trait bound is not met: E0277, the missing-promise error from lesson 8.4. Each direction has its own derive (lesson 9.1).

error[E0277]: the trait bound `Message: serde::Serialize` is not satisfied
    --> src/main.rs:11:42
     |
  11 |     println!("{}", serde_json::to_string(&m).unwrap());
     |                    --------------------- ^^ unsatisfied trait bound
     |                    |
     |                    required by a bound introduced by this call
     |
help: the trait `Serialize` is not implemented for `Message`
    --> src/main.rs:4:1
     |
   4 | struct Message {
     | ^^^^^^^^^^^^^^
     = note: for local types consider adding `#[derive(serde::Serialize)]` to your `Message` type
     = note: for types from other crates check whether the crate offers a `serde` feature flag
     = help: the following other types implement trait `Serialize`:
               &'a T
               &'a mut T
               ()
               (T,)
               (T0, T1)
               (T0, T1, T2)
               (T0, T1, T2, T3)
               (T0, T1, T2, T3, T4)
             and 129 others
note: required by a bound in `serde_json::to_string`
    --> ~/.cargo/registry/src/index.crates.io/serde_json-1.0.154/src/ser.rs:2247:17
     |
2245 | pub fn to_string<T>(value: &T) -> Result<String>
     |        --------- required by a bound in this function
2246 | where
2247 |     T: ?Sized + Serialize,
     |                 ^^^^^^^^^ required by this bound in `to_string`

The program prints: (that went wrong: CHATTERBOX_MODEL is not set) The setting is missing, so env::var gives an Err, and map_err swaps that error for a sentence that names the setting. An Ok would have passed through untouched. It is the same shape as Model::from_env in lesson 9.2, which is why a missing key is a message and never a crash.

It compiles, then panics at run time. Every Message needs a text, and the second record has none, so from_str returns an Err and unwrap() stops the program. serde does not hand back a half-filled history; the text is checked at the door (lesson 9.1). Chatterbox's load uses ? instead, so the problem is reported, not a crash.

It does not compile: E0277. from_str fails with a serde_json::Error, but first_text promises a ChatError. ? converts between the two only if someone wrote impl From<serde_json::Error> for ChatError, and nobody did, so the compiler says ? could not convert the error. Lesson 9.2 wrote that block for reqwest's error.

error[E0277]: `?` couldn't convert the error to `ChatError`
  --> src/main.rs:14:60
   |
13 | fn first_text(saved: &str) -> Result<String, ChatError> {
   |                               ------------------------- expected `ChatError` because of this
14 |     let history: Vec<Message> = serde_json::from_str(saved)?;
   |                                 ---------------------------^ the trait `From<serde_json::Error>` is not implemented for `ChatError`
   |                                 |
   |                                 this can't be annotated with `?` because it has type `Result<_, serde_json::Error>`
   |
note: `ChatError` needs to implement `From<serde_json::Error>`
  --> src/main.rs:9:1
   |
 9 | enum ChatError {
   | ^^^^^^^^^^^^^^
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait