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

【One-Line Pitch】 The definitive guide to Rust, teaching you systems programming with memory safety, zero-cost abstractions, and fearless concurrency—essential for developers wanting high-performance, reliable software without garbage collection. 【Book Arc】 - **Opening (~0%–10%)**: Covers installation via rustup, creating projects with Cargo, and writing your first "Hello, world!" program. Introduces Cargo's build system, including `cargo check` for fast compilation checks and `cargo build --release` for optimized binaries, establishing the workflow for all subsequent chapters. - **Early (~10%–23%)**: Explores fundamental data types (tuples, arrays), control flow with `if` expressions, and the critical concept of ownership—how Rust manages memory through move semantics, borrowing, and slices. Includes practical examples like the rectangle area program using structs and methods. - **Early (~23%–32%)**: Delves into structs, methods, and associated functions, then transitions to the module system—packages, crates, modules, and paths. Demonstrates how to organize code with `super` for relative paths and discusses file layout conventions (modern vs. legacy `mod.rs` style). - **Middle (~39%–48%)**: Covers string manipulation with `format!` macro, error handling with `panic!` for unrecoverable errors and `Result<T, E>` for recoverable ones, including the `?` operator for error propagation. Introduces generics and traits, explaining monomorphization and how trait bounds enable compile-time polymorphism without runtime cost. 【Key Takeaways】 - **Cargo is your project backbone** (Opening): Master `cargo new`, `build`, `run`, and `check`—the latter skips binary generation for faster feedback. Use `cargo build --release` for optimized production binaries, and rely on `Cargo.lock` for reproducible builds. (Early) - **Ownership is Rust's core innovation** (Early): Every value has a single owner; moving a value transfers ownership, and references (`&`) allow borrowing without taking ownership. This eliminates data races and memory leaks at compile time, not runtime. (Early) - **Slices provide safe, efficient access** (Early): String slices (`&str`) let you reference parts of a string without copying, but must respect UTF-8 character boundaries. Returning slices from functions like `first_word` avoids the pitfalls of returning indices. (Early) - **Structs organize related data** (Early): Define custom types with named fields, implement methods in `impl` blocks, and use associated functions (like `String::from`) as constructors. The rectangle example shows progressive refactoring from variables to structs. (Early) - **Modules manage code organization** (Early): Packages contain crates, crates contain modules, and paths navigate the hierarchy. Use `super` for parent-relative paths and choose between modern file layout (`module.rs`) and legacy `mod.rs` style—but don't mix them. (Early) - **Error handling is explicit, not exceptional** (Middle): Rust has no exceptions; use `panic!` for unrecoverable errors (with options to unwind or abort) and `Result<T, E>` for recoverable ones. The `?` operator propagates errors while converting types via the `From` trait. (Middle) - **Generics are zero-cost abstractions** (Middle): Generic types and functions are monomorphized at compile time—the compiler generates specialized code for each concrete type, so you get flexibility without runtime overhead. Trait bounds enforce required behaviors at compile time. (Middle) 【Reading Tips】 - **Skim the early Cargo sections** (~0%–3%) if you're already familiar with build tools; just remember the key commands and the `Cargo.lock` purpose. Focus instead on the ownership chapter (~13%–19%), which is the conceptual foundation. - **Deep-read the ownership and borrowing chapters** (~13%–23%): These are the hardest for newcomers. Work through the examples with pen and paper, tracing which variable owns what data and when moves occur. - **Pay attention to compiler error messages** throughout—they're pedagogical tools. The book shows real errors (like missing lifetime specifiers) and explains the fixes, teaching you to read and resolve Rust's diagnostic output. - **Practice the module system** (~29%–32%) by creating multi-file projects yourself; the concepts of paths, privacy, and `super` are best learned hands-on rather than just reading. - **Use the error handling chapter** (~39%–42%) as a reference: understand when to use `panic!` vs. `Result`, and how `?` simplifies error propagation. This pattern appears throughout real-world Rust code. 【Coverage Limits】 Excerpts cover roughly the first half of the book (through generics and traits). Later chapters on lifetimes in depth, closures, iterators, smart pointers, concurrency, and async/await are not represented in this guide.