1. Rust for C programmers
    1. Why Rust
    2. What makes Rust special
    3. About the book
    4. About the authors
  3. The basic tructure of a Rust program
    1. The build system
    2. The main function
    3. Variables and mutability
    4. Data types
    5. Constants and statics
    6. Functions and control flow
    7. Modules and crates
    8. Use statements and namespacing
    9. Traits and implementations
    10. Macros
    11. Error handling
    12. Memory safety and ownership
    13. Expressions_and_Statements
    14. Code conventions and style
    15. Comments and documentation
    16. Additional topics
    17. Summary
    18. Closing thoughts
  5. Installing Rust
    1. For Linux users
    2. Experimenting in the playground
  7. Rustc and Cargo
    1. Compiling with Rustc
    2. Introduction to Cargo
    3. Further resources
  9. Common_programming_concepts
    1. Keywords
    2. Expressions and statements
    3. Data types
    4. Variables and mutability
    5. Operators
    6. Numeric literals and their type
    7. Overflow for arithmetic operations
    8. Performance for numeric types
    9. Comments in Rust
    10. Summary
    11. Closing thoughts
  11. Ownership and memory management
    1. Overview of ownership
    2. Moves, cloning, and copying
    3. Borrowing and references
    4. The string type
    5. Slices -- borrowing subranges
    6. Lifetimes of references
    7. Smart pointers
    8. Unsafe Rust
    9. Comparison with C
    10. Summary
    11. Closing thoughts
  13. Control flow
    1. Conditional statements
    2. Loops
    3. Control flow in Rust and C
    4. Summary
    5. Closing_thoughts
  15. Functions
    1. Defining and calling functions
    2. The main function
    3. Parameters and return types
    4. Default and named arguments
    5. Slices as parameters
    6. Tuples as parameters
    7. Function pointers
    8. Nested functions and scope
    9. Generics in functions
    10. Recursion
    11. Inlining functions
    12. Method call syntax
    13. Function overloading
    14. Type inference for return types
    15. Variadic functions and macros
    16. Summary
    17. Exercises
    18. Closing thoughts
  17. Structs
    1. Defining structs
    2. Instantiating structs
    3. Updating struct instances
    4. Tuple structs
    5. Unit like structs
    6. Methods, associated functions
    7. The self parameter
    8. Getters and setters
    9. Structs and ownership
    10. References and lifetimes
    11. Generic structs
    12. Rust structs versus classes
    13. Derived traits
    14. Additional topics
    15. Exercises
    16. Summary
    17. Closing thoughts
  19. Enums and pattern matching
    1. Understanding enums
    2. Basic enums
    3. Enums with data
    4. Using enums in code
    5. Memory layout of enums
    6. Enums vs inheritance in OOP
    7. Limitations of enums
    8. Enums as function parameters
    9. Option and Result types
    10. Summary
    11. Closing thoughts
  21. Traits, generics, and lifetimes
    1. Understanding traits
    2. Generics in Rust
    3. Lifetimes in Rust
    4. Traits in depth
    5. Advanced generics
    6. Summary
    7. Closing thoughts
  23. Closures in Rust
    1. Introduction to closures
    2. Using closures
    3. Closure traits
    4. Working with closures
    5. Closures and concurrency
    6. Performance considerations
    7. Additional topics
    8. Summary
  25. Mastering iterators
    1. Introduction to iterators
    2. Common iterator methods
    3. Creating custom iterators
    4. Advanced iterator concepts
    5. Performance considerations
    6. Practical examples
    7. Additional topics
    8. Iterators for complex structures
    9. Summary
  27. Option types
    1. Introduction to option types
    2. Using option types
    3. Option types in other languages
    4. Performance considerations
    5. Benefits of using option types
    6. Best practices
    7. Practical examples
    8. Summary
  29. Error handling with Result
    1. Introduction to error handling
    2. Unrecoverable errors
    3. The Result type
    4. Error propagation with ?
    5. Practical examples
    6. Handling multiple error types
    7. Best practices
    8. Summary
  31. Type conversions
    1. Introduction to type conversions
    2. Casting with as
    3. Using the From and Into traits
    4. Fallible conversions
    5. Reinterpreting data types
    6. String processing and parsing
    7. Best practices
    8. Summary
  33. Crates, modules, and packages
    1. Packages
    2. Crates
    3. Modules
    4. The prelude
    5. Best practices
    6. Summary
  35. Using Cargo
  36. Collections and Container Types
  37. Pattern Matching in Detail
  38. Threads and Concurrency
  39. Smart Pointers
  40. Testing
  41. Appendix
  42. Private policy