9.xChapter 9 summary and quiz

Last updated June 12, 2026

Chapter 8 taught Rust's strictest idea; this chapter taught the idea that makes the strictness livable. Quick review, and then the quiz makes you use all of it at once.

Quick review

A reference is a value that refers to another value without owning it; creating one is called borrowing (9.1). The & appears on both sides of an agreement: &message at the call site lends, text: &String in the signature receives. A reference owns nothing, so dropping one frees nothing, and the borrowed value's one true owner carries on untouched. Plain & references are read-only, and any number may exist at once.

A mutable reference, spelled &mut, is a loan with writing permission (9.2). Mutation is written down three times (a mut binding, &mut at the call site, &mut T in the signature), which is why read_line(&mut name) looks the way it has since chapter 1. The borrow checker enforces the chapter's two rules: at any given time a value has either one mutable reference or any number of immutable ones, and references must always be valid. Borrows last from creation to last use, not to the closing brace, so reordering a few lines is a legitimate and common fix. The four refusals you'll meet most (9.3): E0596 (borrowing &mut from a non-mut binding), E0502 (writer while readers live), E0382 (use after move, usually cured with & rather than .clone()), and E0506 (assigning over a borrowed value).

Parameter design is a four-row table (9.4): Copy types by value, &T to read, &mut T to modify in place, owned T to keep or consume. Results travel in return values, not &mut out-parameters. A dangling reference, one that outlives its value, is rule 2's forbidden object (9.5): a function can return a reference only if it borrows from something living outside the call, which is why returning a view of a parameter compiles and returning a view of a local is refused at the signature. A lifetime is the stretch of program during which a value is alive; 'static, the whole-program lifetime of string literals, is the only one you'll spell until chapter 17.

A slice is a reference with a range: &temperatures[1..4] borrows a view of part of a sequence, of type &[i32], an address plus a length (9.6). Functions take slices rather than arrays for the same reason text functions take &str rather than &String, and that reason is now mechanical: deref coercion and its sibling conversions shrink an owner-shaped argument into the view a parameter asks for (9.7). A string slice is precisely that machinery aimed at text. Carve with byte indexes at character boundaries or Rust panics rather than splits a char; views found by scanning the text itself are always safe.

The chapter's thesis, witnessed in transcript form: the index version of first_word shipped a stale-bookkeeping bug, and the slice version made the same bug fail to compile. The borrow checker isn't only guarding memory. It guards the connection between your data and the facts you derive from it.

Quiz time

Question #1

From memory: state the two rules of references, and name the part of the compiler that enforces them.

Question #2

Compiles or not? For each failure, name the error code.

a)

fn main() {
    let recipe = String::from("toast");
    let a = &recipe;
    let b = &recipe;
    println!("{a} and {b}");
}

b)

fn main() {
    let mut recipe = String::from("toast");
    let a = &recipe;
    recipe.push_str(" with jam");
    println!("{a}");
}

c)

fn main() {
    let recipe = String::from("toast");
    let copy = recipe;
    println!("{recipe}");
}

d)

fn main() {
    let mut recipe = String::from("toast");
    let a = &mut recipe;
    a.push_str(" with jam");
    let b = &mut recipe;
    b.push_str(" and tea");
    println!("{recipe}");
}

Question #3

Match each snippet to its error code (E0382, E0499, E0502, E0506, E0596). One code per snippet, no compiler.

a)

let mut s = String::from("hi");
let r1 = &mut s;
let r2 = &mut s;
println!("{r1} {r2}");

b)

let s = String::from("hi");
let r = &mut s;
r.push_str("!");

c)

let mut s = String::from("hi");
let r = &s;
s = String::from("bye");
println!("{r}");

d)

let s = String::from("hi");
let t = s;
println!("{s}");

e)

let mut s = String::from("hi");
let r = &s;
s.push_str("!");
println!("{r}");

Question #4

The capstone. Write a program that reads a line of text, prints its first word, then prints that word shouted with excitement added. Requirements: a first_word(s: &str) -> &str (yours from lesson 9.7, or rewrite it), a shouted(text: &str) -> String, and an add_excitement(text: &mut String) that appends !!!. Sample run, typing go rust go:

first word: go
GO!!!

Design check before you peek: which of your functions borrow, which one needs a writable loan, and which value in main owns heap text?

use std::io;

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b' ' {
            return &s[..i];
        }
        i += 1;
    }
    s
}

fn shouted(text: &str) -> String {
    text.to_uppercase()
}

fn add_excitement(text: &mut String) {
    text.push_str("!!!");
}

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("failed to read line");
    let phrase = input.trim();

    let word = first_word(phrase);
    println!("first word: {word}");

    let mut cheer = shouted(word);
    add_excitement(&mut cheer);
    println!("{cheer}");
}

Eight chapters of String and numbers were the price of admission. With ownership (chapter 8) and borrowing (this chapter) in hand, you can finally be trusted with the keys to the type system: chapter 10 lets you define types of your own, and the &self in every method you'll ever write is this chapter wearing a new coat.