19.xChapter 19 summary and quiz

Last updated June 13, 2026

This chapter handed you the tools that make day-to-day Rust expressive. Review, then a capstone that uses most of them at once.

Quick review

A closure is a function written inline that can capture variables from its surrounding scope (19.1). It captures by the lightest means that compiles, & to read, &mut to modify, or by value, and move forces every capture to be owned (needed when the closure must outlive the originals). A closure's parameter and return types are inferred from use, then fixed.

Each closure has a unique anonymous type, so you name closures in signatures through the Fn traits (19.2): Fn (reads captures, callable repeatedly), FnMut (mutates captures), FnOnce (may consume captures, callable once). They nest Fn ⊂ FnMut ⊂ FnOnce; a parameter should ask for the most permissive bound it needs. Take a closure with impl Fn(...) -> ... and return one with impl Fn plus move. Non-capturing closures and named functions also fit the fn pointer type.

An iterator is anything implementing Iterator: one required method next(&mut self) -> Option<Item>, returning Some per value and None when done (19.3). Get one from a collection with iter() (&T), iter_mut() (&mut T), or into_iter() (T), the &/&mut/owned choice again. Iterators are lazy: they do nothing until consumed.

Adapters transform one iterator into another and are lazy and chainable (19.4): map, filter, enumerate, zip, rev, chain. Consumers drive the iterator to a result (19.5): collect (needs a target type, via annotation or turbofish), sum, count, fold (the general reduction), and the short-circuiting find, any, all. A for loop is sugar for IntoIterator::into_iter plus while let Some(x) = iter.next() (19.6), which is why for x in &v was v.iter() all along. Pipelines are a zero-cost abstraction, identical to hand-written loops in release builds (19.7); choose the style that reads clearest.

Quiz time

Question #1

When a closure captures a variable, how does the compiler decide whether to borrow it (&), borrow it mutably (&mut), or move it, and what does move override?

Question #2

Why must you specify a type for collect but rarely for count?

Question #3

Predict the output:

let v = vec![1, 2, 3, 4];
v.iter().filter(|x| **x > 1).map(|x| x * 10);
println!("done");

Question #4

Which Fn trait does each closure implement: |x| x + 1, |x| { vec.push(x) } (where vec is captured), and move |x| consume(captured_string, x)?

Chapter capstone

Put the chapter to work. Given a block of text, produce a word-frequency report: the five most common words, lowercased, with their counts, ignoring punctuation. This touches closures, adapters, a consumer building a HashMap, and a small sort.

Write a program that, for the input below, prints each of the top five words and its count, most frequent first.

fn main() {
    let text = "the cat sat on the mat. The dog sat on the log. \
                the cat and the dog sat.";

    // your code here
}

use std::collections::HashMap;

fn main() {
    let text = "the cat sat on the mat. The dog sat on the log. \
                the cat and the dog sat.";

    // Split into words, lowercase, strip non-alphabetic edges, count.
    let mut counts: HashMap<String, u32> = HashMap::new();
    for word in text.split_whitespace() {
        let cleaned: String = word
            .chars()
            .filter(|c| c.is_alphabetic())
            .collect::<String>()
            .to_lowercase();
        if !cleaned.is_empty() {
            *counts.entry(cleaned).or_insert(0) += 1;
        }
    }

    // Sort entries by count, descending, and take the top five.
    let mut ranked: Vec<(String, u32)> = counts.into_iter().collect();
    ranked.sort_by(|a, b| b.1.cmp(&a.1));

    for (word, n) in ranked.iter().take(5) {
        println!("{word}: {n}");
    }
}

the: 5
sat: 3
cat: 2
on: 2
dog: 2

You can now move data through expressive pipelines and bottle up behavior as values. Chapter 20 turns all of this outward: it builds a real command-line program, reading arguments and files and standard input, and the iterator and closure tools you just learned are exactly what make its text-search project read so cleanly.