The Rust Programming Language, 3rd Edition (Steve Klabnik, Carol Nichols, Chris Krycho)（Z-Library）

【One-Line Pitch】 A patient, example-driven path into Rust that treats the language's strict compiler as a teaching tool rather than an obstacle. Best for programmers who already know at least one language and want to understand *why* Rust is built the way it is, not just how to make it compile. 【Book Arc】 - **Opening (~0%–10%)**: Tooling and first contact — installing Rust via rustup, writing "Hello, world!", and learning Cargo's core loop (`new`, `build`, `run`, `check`, `build --release`), plus early data types like arrays versus vectors. - **Early (~10%–32%)**: The language's spine — control flow, functions, then ownership, borrowing, and slices, followed by structs, enums, pattern matching, and how packages, crates, modules, and `pub` organize real code. - **Middle (~39%–52%)**: Collections and abstraction — strings and UTF-8 subtleties, hash maps, error handling with `panic!` versus `Result`, then generics and traits as the tools for removing duplication. - **Late (beyond ~52%)**: The excerpts do not cover this stretch in detail; the book's own forward references point toward lifetimes, smart pointers, concurrency, testing, and Cargo/ecosystem topics in later chapters. - **Ending (not covered)**: The excerpts do not cover the closing chapters, so any final project or advanced-pattern material is outside this guide's view. 【Key Takeaways】 - **Cargo is the entry point to everything** (Opening): `cargo check` for fast feedback versus `cargo build --release` for optimized binaries, with dependency versions pinned through `Cargo.toml` and `Cargo.lock` — the book frames tooling as part of the language, not an afterthought. - **Ownership and borrowing are the conceptual core** (Early): scope-based validity, the `String` heap example, and the rule that you cannot hold a mutable and immutable borrow simultaneously are explained through compiler errors rather than abstract rules. - **Slices prevent whole classes of bugs at compile time** (Early): the `first_word` example shows how a slice-based API turns a latent runtime bug into an immediate borrow-checker error — the book's recurring argument that Rust moves mistakes earlier. - **Structs and enums are the vocabulary of domain modeling** (Early): grouping related data with named fields, attaching behavior via `impl` blocks, and using enums plus pattern matching to express variants; multiple `impl` blocks are shown as valid and occasionally useful. - **Module privacy is a design tool** (Early): the "modules cheat sheet" and the restaurant example demonstrate that `pub` on structs exposes fields selectively, while public enums expose all variants by default. - **Strings are bytes, scalar values, and grapheme clusters — not characters** (Middle): UTF-8 indexing is deliberately disallowed, and the book uses a non-Latin example to show why byte indexing would return misleading values. - **Errors are values, not exceptions** (Middle): out-of-bounds indexing panics with a clear message and backtrace guidance, while recoverable failures flow through `Result` and helpers like `fs::read_to_string`. - **Generics and traits exist to kill duplication** (Middle): the repeated "find the largest number" example motivates both, and traits are introduced as contracts the compiler enforces on implementors. 【Reading Tips】 - **Deep-read the ownership and borrowing chapters.** They are the load-bearing wall for everything later; skimming here will make later chapters feel arbitrary. - **Type the examples and read the compiler errors carefully.** The book deliberately shows failing code and its diagnostics — that error literacy is a transferable skill. - **Skim the installation and Cargo basics if you already use a package manager.** Return to the Cargo chapter later for dependency and workspace details. - **Treat the modules cheat sheet as a reference card.** It is explicitly written as a lookup, not a narrative to memorize in one pass. - **Pause on the UTF-8 and string-indexing discussion.** It is short but explains a design decision that surprises newcomers from C, Python, or JavaScript. 【Coverage Limits】 This guide is built from stratified excerpts covering roughly the first half of the book; later chapters on lifetimes, smart pointers, concurrency, testing, and ecosystem tooling are referenced but not summarized here.