Chapter 8: Iterators and closures
The chapter introduces method chaining as passing one method’s output into the next and identifies iterators and closures as tools used with that style.
After this chapter you will be able to
- Method chaining flow. Explain how one method’s output becomes the next method’s input until the desired result is reached.
- Chained methods building a Vec. Trace how the example starts with a range, uses .take() to select ten items, and uses .collect() to make a Vec; explain why the collection type must be specified.
- Iterator items and stopping. Explain that an iterator gives out items one at a time and that repeated calls to .next() return Some for an item or None when iteration is finished.
- Three ways to iterate. Distinguish .iter(), .iter_mut(), and .into_iter() by whether they yield references, mutable references, or values, and describe the effect each has in the section's vector examples.
- Mapping and acting on items. Distinguish using .map() to pass transformed items into a new iterator from using .for_each() to act on every item, and explain why the mapped example calls .collect().
- Custom Iterator implementation. Describe how the BookCollection example implements Iterator with an associated Item type and a .next() method, and explain how its chosen .next() behavior determines the items returned.
- Closure syntax and use. Describe how a closure is written with vertical bars, bound to a variable, and called. Explain that it can take inputs and that a longer closure can use a code block.
- Surrounding variable capture. Explain how a closure can use variables from outside its body without listing them between its bars. Distinguish this from a closure-like anonymous function that encloses no outside variables, while noting the book calls both closures.
- Closures as method arguments. Explain why methods such as .for_each() take closures: the caller can change what happens to each item while supplying a closure with the required signature.
- Closure-based fallback values. Distinguish .unwrap_or_else() from .unwrap_or() and describe how the section's missing-index example obtains its fallback value.
- Indexed iterator items. Describe what .enumerate() adds to an iterator, and distinguish the section's use of .for_each() from .map().
- Lazy iterator chains. Explain that methods such as .iter(), .enumerate(), and .map() build an iterator structure rather than immediately processing every item, and that a consuming method such as .collect() makes it do the work.
- Collecting paired vectors. Describe how the section turns separate vectors of keys and values into a HashMap using .into_iter(), .zip(), and .collect().
- Ignored closure argument. Explain what `|_|` means in a closure and why it can replace `||` when the closure must take an argument it will not use.
What it builds on
- Collection types (chapter 3) · Introduces collection types.
- Loops (chapter 3) · The earlier introduction to loops makes the imperative example familiar.
- Vectors (chapter 3) · The example produces a Vec, a collection introduced earlier.
- Option (chapter 5) · The Some and None variants of Option.
- Mutable references (chapter 2) · Mutable references.
- All you need are the method signatures (chapter 7) · Implementing the requirements of a trait.
- The orphan rule (chapter 7) · The orphan rule motivating a book collection type of the author's own.
- Declaring variables and code blocks (chapter 1) · Variables and code blocks provide familiar points of comparison.
Section by section
Introduction
The chapter introduces method chaining as passing one method’s output into the next and identifies iterators and closures as tools used with that style.
- Method chaining flow: Explain how one method’s output becomes the next method’s input until the desired result is reached.
Why it matters: This explains the basic pattern behind the chapter’s functional-style examples. - Iterators and collections: State what iterators are presented as a convenient way to work with.
Why it matters: It connects the chapter’s focus on iterators to the collections you have already encountered. - Closure defining features: Describe closures as unnamed functions that can capture variables from their scope.
Why it matters: These two features distinguish the closures introduced as a focus of the chapter.
Key terms: method chaining, output, input, iterators, collections, closures, scope, capture variables
8.1 Chaining methods
The section contrasts imperative and functional Rust code and shows how chaining methods can build a Vec.
- Imperative and functional styles: Distinguish imperative code that gives individual instructions from functional code that passes the result of one expression into the next.
Why it matters: This contrast explains why the chained example can replace several separate instructions. - Chained methods building a Vec: Trace how the example starts with a range, uses .take() to select ten items, and uses .collect() to make a Vec; explain why the collection type must be specified.
Why it matters: Following each method’s result makes a chain easier to read and understand.
Key terms: imperative style, functional style, expressions, range, iterator, .take(), .collect(), Vec, chain
8.2 Iterators
This section explains how iterators yield items, how different iterator methods affect a collection, and how to implement an iterator for a custom type.
- Iterator items and stopping: Explain that an iterator gives out items one at a time and that repeated calls to .next() return Some for an item or None when iteration is finished.
Why it matters: This explains both how a for loop gets its items and how it knows when to stop. - Three ways to iterate: Distinguish .iter(), .iter_mut(), and .into_iter() by whether they yield references, mutable references, or values, and describe the effect each has in the section's vector examples.
Why it matters: Choosing the right method lets you read, modify, or take values without confusing those effects. - Mapping and acting on items: Distinguish using .map() to pass transformed items into a new iterator from using .for_each() to act on every item, and explain why the mapped example calls .collect().
Why it matters: It clarifies why processing iterator items does not always produce a new collection. - Custom Iterator implementation: Describe how the BookCollection example implements Iterator with an associated Item type and a .next() method, and explain how its chosen .next() behavior determines the items returned.
Why it matters: It shows that the type implementing Iterator controls what each step yields.
Key terms: iterator, .next(), Option, Some, None, .iter(), .iter_mut(), .into_iter(), references, mutable references
8.3 Closures and closures inside iterators
This section introduces closures as callable, unnamed functions and explains how they can use variables from their surrounding environment.
- Closure syntax and use: Describe how a closure is written with vertical bars, bound to a variable, and called. Explain that it can take inputs and that a longer closure can use a code block.
Why it matters: Recognizing the bars and the callable form helps you read closures in Rust code. - Surrounding variable capture: Explain how a closure can use variables from outside its body without listing them between its bars. Distinguish this from a closure-like anonymous function that encloses no outside variables, while noting the book calls both closures.
Why it matters: This explains why a closure may use a variable that does not appear among its inputs.
Key terms: closure, anonymous function, ||, code block, environment, encloses
8.3.1 Closures inside of methods
This section shows how closures customize method behavior, how a closure can provide a fallback value, and how to add indexes to iterator items.
- Closures as method arguments: Explain why methods such as .for_each() take closures: the caller can change what happens to each item while supplying a closure with the required signature.
Why it matters: It explains why the same method can be useful for different tasks. - Closure-based fallback values: Distinguish .unwrap_or_else() from .unwrap_or() and describe how the section's missing-index example obtains its fallback value.
Why it matters: A closure can choose a fallback based on more than a single supplied value. - Indexed iterator items: Describe what .enumerate() adds to an iterator, and distinguish the section's use of .for_each() from .map().
Why it matters: It helps you choose whether to view indexed items or transform items for further use.
Key terms: closure, .for_each(), signature, .unwrap_or(), .unwrap_or_else(), default value, .enumerate(), .map(), index, iterator
8.3.2 Closures: Lazy and fast
This section explains why iterator chains do no work until consumed, how that supports fast code, and how to collect paired iterators into a HashMap.
- Lazy iterator chains: Explain that methods such as .iter(), .enumerate(), and .map() build an iterator structure rather than immediately processing every item, and that a consuming method such as .collect() makes it do the work.
Why it matters: It explains why a .map() chain without a consumer can run without producing a result. - Iterator performance rationale: Explain how the section connects lazy iterator chains to Rust’s idea of zero-cost abstractions.
Why it matters: It gives the reason the section presents expressive iterator chains as compatible with fast code. - Collecting paired vectors: Describe how the section turns separate vectors of keys and values into a HashMap using .into_iter(), .zip(), and .collect().
Why it matters: It shows that collecting an iterator can build a collection other than a Vec. - Character indices method: State how the section introduces .char_indices() in relation to .enumerate().
Why it matters: It gives the reader a name for working with character indices.
Key terms: iterator, .map(), .collect(), lazy, consume, zero-cost abstractions, run time, HashMap, .into_iter(), .zip()
8.3.3 |_| in a closure
Explains that `|_|` lets a closure accept a required argument without using it.
- Ignored closure argument: Explain what `|_|` means in a closure and why it can replace `||` when the closure must take an argument it will not use.
Why it matters: It helps you write a closure when an argument is required but its value is irrelevant.
Key terms: closure, |_|, ||, argument
8.4 Summary
Where this is used later
- Helpful methods for closures and iterators (chapter 9) · Earlier introduction to chaining methods.
- The dbg! macro and .inspect (chapter 9) · The idea of chaining methods.
- Writing builder methods (chapter 15) · Chaining method calls.
- Mapping and filtering (chapter 9) · The idea of working through items with an iterator.
- Some more iterator and related methods (chapter 9) · Working with values through an iterator
- (chapter intro) (chapter 9) · Introduces closures and their use with iterators.
- Spawning threads (chapter 11) · Introduces closures.
- Types of closures (chapter 11) · The reader has encountered closures before this introduction to their traits.
Concepts explained in this chapter
- iteratorAn iterator is a Rust value implementing the Iterator trait that produces a sequence of items, typically through repeated calls to next.
- closureA closure is an anonymous Rust function-like value that can capture variables from its surrounding environment and be passed as an argument.
- data transformationmap is an iterator adaptor that applies a transformation to each item and returns a new iterator producing the transformed items.
- collectcollect is a Rust iterator method that gathers produced items into a collection or another type inferred or specified by the program.
- into_iterinto_iter is a Rust method that converts a collection or other iterable value into an iterator, with item ownership determined by the receiver.
- iterator methoditer is a Rust collection method that returns an iterator yielding immutable references to the collection's items.
- associated typeAn associated type is a type declaration attached to a Rust trait whose concrete value is specified for each implementation.
- nextnext is the iterator method that advances iteration and returns an Option containing the next item or indicating that iteration has ended.
- iter_mutiter_mut is a Rust collection method that returns an iterator yielding mutable references to the collection's items.
- for_eachfor_each is a Rust iterator method that applies a closure to every item and produces no meaningful result.
- blank identifierA blank identifier is a language-defined name or symbol that receives or matches a value without binding it to a usable variable.
- optionAn option type is a type that explicitly represents either a value of a specified type or the absence of a value.
← Chapter 7: Traits: Making different types do the same thing
Chapter 9: Iterators and closures again! →
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.