Rust Cookbook (Vigneshwer Dhinakaran)（Z-Library）

【One-Line Pitch】 A hands-on recipe collection that teaches Rust by building small, runnable programs—from installing the toolchain to threads, modules, and macros. Best for developers who already program in another language and want to learn Rust's syntax, ownership model, and Cargo workflow by doing. 【Book Arc】 - **Opening (~0%–10%)**: Sets up the Rust toolchain on Linux, macOS, and Windows, explains PATH/linker pitfalls, and frames the "why Rust" argument around system programming. Solves the first barrier: getting a working compiler and Cargo. - **Early (~10%–32%)**: Core language fundamentals via recipes—variables and mutability, strings, arrays and slices, vectors, tuples, arithmetic, constants, type casting, loops, and enums. Builds the vocabulary you need before anything else. - **Middle (~32%–48%)**: Ownership, borrowing, structs, traits, and code organization with modules, crates, and visibility rules (`pub`, `super`, `self`). This is where Rust's distinctive mental model gets exercised. - **Late (~39%–48%, overlapping)**: Cargo as a full project tool—dependencies, metadata, `cargo test`, and CI integration via Travis. Moves you from single files to maintainable projects. - **Late (~48%+)**: Concurrency and parallelism—threads, spawning multiple threads, holding threads in vectors, channels for sharing data, safe mutable access, and child processes. - **Ending (later chapters)**: Error handling (multiple errors, early returns, `try!`, custom error types, boxing errors) and macros (building macros, matching in macros, common Rust macros). Excerpts do not cover the final chapter ordering in detail. 【Key Takeaways】 - **Rust's value proposition is memory safety without a garbage collector** (Opening): the book opens by arguing why another systems language is needed, tying it to ownership and borrowing rather than syntax novelty. - **Mutability is explicit and central** (Early): `let` vs `let mut`, plus shadowing, are taught as the mechanism behind Rust's avoidance of segfaults and data races. - **Compound types have distinct trade-offs** (Early): arrays are fixed-size and compile-time known (`[T; size]`), slices borrow a section with runtime length, vectors are growable, and tuples group heterogeneous values. - **Ownership changes how you pass data** (Middle): the vector example shows non-primitive values cannot be trivially copied, so functions take references (`&Vec<i32>`) to retain usable ownership afterward. - **Traits extend user-defined types** (Middle): `impl` gives methods, while traits add shared behavior, inheritance-like control, and polymorphism across types. - **Modules default to private** (Middle): visibility must be opted into with `pub`; nested modules and `use`/`super`/`self` manage paths and avoid hardcoded references. - **Cargo is the project backbone** (Late): it handles dependencies, builds, and `cargo test` for unit and integration tests, with CI configurable through a `.travis.yml` pipeline. - **Concurrency is a first-class recipe topic** (Late): threads, thread vectors, channels, and safe mutable access are presented as practical patterns rather than theory. 【Reading Tips】 - **Skim the setup chapter if your toolchain already works.** The PATH, linker, and `rustup.sh` material is troubleshooting reference, not conceptual content. - **Type the recipes rather than reading them.** This is a cookbook; the value is in compiling, breaking, and fixing the small programs. - **Deep-read ownership, borrowing, traits, and modules.** These are the sections where Rust differs most from other languages and where the excerpts show the most explanatory "How it works" content. - **Treat error handling and macros as advanced passes.** Read them after you are comfortable with the fundamentals, since they build on traits and types. - **Use Cargo and testing recipes as your workflow template.** Adopt `cargo test` and CI early so later recipes fit into a real project structure. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book plus chapter listings; later chapters on error handling and macros are only partially represented, and specific recipe details beyond the excerpts are not covered.