فهرست مطالب

• Brief contents
• Contents
• Preface
• Acknowledgments
• About this book
• About the author
• About the cover illustration
• Chapter 1: Feelin’ Rusty
• 1.1 What’s Rust?
• 1.2 What’s unique about Rust?
• 1.3 When should you use Rust?
• 1.4 Tools you’ll need
• Part 1: Pro Rust
• Chapter 2: Project management with Cargo
• 2.1 Cargo tour
• 2.2 Dependency management
• 2.3 Feature flags
• 2.4 Patching dependencies
• 2.5 Publishing crates
• 2.6 Linking to C libraries
• 2.7 Binary distribution
• 2.8 Documenting Rust projects
• 2.9 Modules
• 2.10 Workspaces
• 2.11 Custom building scripts
• 2.12 Rust projects in embedded environments
• Chapter 3: Rust tooling
• 3.1 Overview of Rust tooling
• 3.2 Using rust-analyzer for Rust IDE integration
• 3.3 Using rustfmt to keep code tidy
• 3.4 Using Clippy to improve code quality
• 3.5 Reducing compile times with sccache
• 3.6 Integration with IDEs, including Visual Studio Code
• 3.7 Using toolchains: Stable vs. nightly
• 3.8 Additional tools: cargo-update, cargo-expand, cargo-fuzz, cargo-watch, cargo-tree
• Part 2: Core data
• Chapter 4: Data structures
• 4.1 Demystifying String, str, &str, and 'static str
• 4.2 Understanding slices and arrays
• 4.3 Vectors
• 4.4 Maps
• 4.5 Rust types: Primitives, structs, enums, and aliases
• 4.6 Error handling with Result
• 4.7 Converting types with From/Into
• 4.8 Handling FFI compatibility with Rust’s types
• Chapter 5: Working with memory
• 5.1 Memory management: Heap and stack
• 5.2 Understanding ownership: Copies, borrowing, references, and moves
• 5.3 Deep copying
• 5.4 Avoiding copies
• 5.5 To box or not to box: Smart pointers
• 5.6 Reference counting
• 5.7 Clone on write
• 5.8 Custom allocators
• 5.9 Smart pointers summarized
• Part 3: Correctness
• Chapter 6: Unit testing
• 6.1 How testing is different in Rust
• 6.2 Review of built-in testing features
• 6.3 Testing frameworks
• 6.4 What not to test: Why the compiler knows better than you
• 6.5 Handling parallel test special cases and global state
• 6.6 Thinking about refactoring
• 6.7 Refactoring tools
• 6.8 Code coverage
• 6.9 Dealing with a changing ecosystem
• Chapter 7: Integration testing
• 7.1 Comparing integration and unit testing
• 7.2 Integration testing strategies
• 7.3 Built-in integration testing vs. external integration testing
• 7.4 Integration testing libraries and tooling
• 7.5 Fuzz testing
• Part 4: Asynchronous Rust
• Chapter 8: Async Rust
• 8.1 Runtimes
• 8.2 Thinking asynchronously
• 8.3 Futures: Handling async task results
• 8.4 The async and .await keywords: When and where to use them
• 8.5 Concurrency and parallelism with async
• 8.6 Implementing an async observer
• 8.7 Mixing sync and async
• 8.8 When to avoid using async
• 8.9 Tracing and debugging async code
• 8.10 Dealing with async when testing
• Chapter 9: Building an HTTP REST API service
• 9.1 Choosing a web framework
• 9.2 Creating an architecture
• 9.3 API design
• 9.4 Libraries and tools
• 9.5 Application scaffolding
• 9.6 Data modeling
• 9.7 Declaring the API routes
• 9.8 Implementing the API routes
• 9.9 Error handling
• 9.10 Running the service
• Chapter 10: Building an HTTP REST API CLI
• 10.1 Deciding which tools and libraries to use
• 10.2 Designing the CLI
• 10.3 Declaring the commands
• 10.4 Implementing the commands
• 10.5 Implementing requests
• 10.6 Handling errors gracefully
• 10.7 Testing our CLI
• Part 5: Optimizations
• Chapter 11: Optimizations
• Appendix
• Index