1. 1. Introduction
  2. 2. Types
    1. 2.1. Item 1: Use the type system to express your data structures
    2. 2.2. Item 2: Use the type system to express common behaviour
    3. 2.3. Item 3: Avoid matching Option and Result
    4. 2.4. Item 4: Prefer idiomatic Error variants
    5. 2.5. Item 5: Familiarize yourself with standard traits
    6. 2.6. Item 6: Understand type conversions
    7. 2.7. Item 7: Embrace the newtype pattern
    8. 2.8. Item 8: Use builders for complex types
    9. 2.9. Item 9: Familiarize yourself with reference and pointer types
    10. 2.10. Item 10: Consider using iterator transforms instead of explicit loops
    11. 2.11. Item 11: Implement the Drop trait for RAII patterns
    12. 2.12. Item 12: Prefer generics to trait objects
    13. 2.13. Item 13: Use default implementations to minimize required trait methods
  3. 3. Concepts
    1. 3.1. Item 14: Understand the borrow checker
    2. 3.2. Item 15: Understand lifetimes
    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
  4. 4. Dependencies
    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
  5. 5. Tooling
    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
  6. 6. Asynchronous Rust
    1. 6.1. Item 33: Distinguish between the async and non-async worlds
    2. 6.2. Item 34: Familiarize yourself with executors
    3. 6.3. Item 35: Use the type system to decipher problems
    4. 6.4. Item 36: Understand how Futures are combined
  7. 7. Beyond Standard Rust
    1. 7.1. Item 37: Consider making library code no_std compatible
    2. 7.2. Item 38: Control what crosses FFI boundaries
    3. 7.3. Item 39: Prefer bindgen to manual FFI mappings

Effective Rust

Beyond Standard Rust