Maybe nothing: Option

A chat command can have an argument: the hello in /say hello. But /help has none. A function that looks for the argument will sometimes come back with nothing.

Rust has no null. Instead, a value that might be missing has its own type, Option<T>, which is just an enum (lesson 5.3) with two variants: Some(value) and None.

$ cargo run
Some("hello")
None

line.find(' ') is itself an Option ({:?} in println! prints a value in debug form, which is how Some("hello") shows; later, matches!(x, Pat) is a yes/no match): the position of the first space, or nothing. if let Some(i) = ... reads "if this is a Some, call what is inside i and run the block; otherwise run the else". It is a match with just the one arm you care about.

The return type Option<&str> is a borrowed slice (lesson 4.5) that may be absent. It points into line, so nothing is copied.

You cannot use it as if it were there

error[E0308]: mismatched types
  --> src/main.rs:10:21
   |
10 |     let arg: &str = find_command_arg("/help");
   |              ----   ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&str`, found `Option<&str>`
   |              |
   |              expected due to this
   |
   = note: expected reference `&str`
                   found enum `Option<&str>`
help: consider using `Option::expect` to unwrap the `Option<&str>` value, panicking if the value is an `Option::None`
   |
10 |     let arg: &str = find_command_arg("/help").expect("REASON");
   |                                              +++++++++++++++++

E0308: "mismatched types: expected &str, found Option<&str>". The compiler is saying: this might be nothing, so you cannot treat it as text yet. That is the whole trick. In a language with null, this compiles and crashes when the line was /help. Here the crash is not expressible.

The simplest way out is unwrap_or: "give me the value, or this fallback if there is none".

Chapter 5 comes together. A typed line becomes a Command in parse; find_command_arg pulls out the argument (a bare /say is handled explicitly, and /say with the space is what an argument needs, as in 5.3), and unwrap_or("") says what a bare /say means. handle turns the command into a reply Message. The help text now lists /say, and a reply is a Message from bot instead of an echo: string. matches!(cmd, Command::Quit) in main is a yes/no match.

$ cargo run
bot: commands: /help /quit /say <text>
bot: hello
bot: 
bot: unknown: /dance
bot: bye

Run it and watch the last line: after /quit the loop breaks, so /say never is never handled. The program now parses text into a typed value, handles every case the compiler can see, and has no null anywhere. Chapter 6 gives it a memory: the whole conversation in a list.