https://www.lurklurk.org/effective-rust/title-page.html

[ ]

 1. Effective Rust
 2. Preface
 3. 1. Types
 4.
     1. 1.1. Item 1: Use the type system to express your data
        structures
     2. 1.2. Item 2: Use the type system to express common behavior
     3. 1.3. Item 3: Prefer Option and Result transforms over
        explicit match expressions
     4. 1.4. Item 4: Prefer idiomatic Error types
     5. 1.5. Item 5: Understand type conversions
     6. 1.6. Item 6: Embrace the newtype pattern
     7. 1.7. Item 7: Use builders for complex types
     8. 1.8. Item 8: Familiarize yourself with reference and pointer
        types
     9. 1.9. Item 9: Consider using iterator transforms instead of
        explicit loops
 5. 2. Traits
 6.
     1. 2.1. Item 10: Familiarize yourself with standard traits
     2. 2.2. Item 11: Implement the Drop trait for RAII patterns
     3. 2.3. Item 12: Understand the trade-offs between generics and
        trait objects
     4. 2.4. Item 13: Use default implementations to minimize
        required trait methods
 7. 3. Concepts
 8.
     1. 3.1. Item 14: Understand lifetimes
     2. 3.2. Item 15: Understand the borrow checker
     3. 3.3. Item 16: Avoid writing unsafe code
     4. 3.4. Item 17: Be wary of shared-state parallelism
     5. 3.5. Item 18: Don't panic
     6. 3.6. Item 19: Avoid reflection
     7. 3.7. Item 20: Avoid the temptation to over-optimize
 9. 4. Dependencies
10.
     1. 4.1. Item 21: Understand what semantic versioning promises
     2. 4.2. Item 22: Minimize visibility
     3. 4.3. Item 23: Avoid wildcard imports
     4. 4.4. Item 24: Re-export dependencies whose types appear in
        your API
     5. 4.5. Item 25: Manage your dependency graph
     6. 4.6. Item 26: Be wary of feature creep
11. 5. Tooling
12.
     1. 5.1. Item 27: Document public interfaces
     2. 5.2. Item 28: Use macros judiciously
     3. 5.3. Item 29: Listen to Clippy
     4. 5.4. Item 30: Write more than unit tests
     5. 5.5. Item 31: Take advantage of the tooling ecosystem
     6. 5.6. Item 32: Set up a continuous integration (CI) system
13. 6. Beyond Standard Rust
14.
     1. 6.1. Item 33: Consider making library code no_std compatible
     2. 6.2. Item 34: Control what crosses FFI boundaries
     3. 6.3. Item 35: Prefer bindgen to manual FFI mappings
15. Afterword
16. Index

  * Light
  * Rust
  * Coal
  * Navy
  * Ayu

Effective Rust

 
[                    ]





 
                           Effective Rust

 
             35 Specific Ways to Improve Your Rust Code



 
                           David Drysdale




A printed and ebook version of this book is published by O'Reilly
Media:

                                Release date: April 2024
                                Page count: 280 pages
                                ISBN: 9781098151409

                                Available at:
Printed book cover showing crab
                                  *  Amazon.com
                                  *  Amazon.co.uk
                                  *  Barnes & Noble
                                  *  Waterstones
                                  * and many other book stores.

 

Effective Rust by David Drysdale
(c) 2024 Galloglass Consulting Limited

Creative Commons Attribution-NonCommercial-NoDerivatives 4.0
International License