1. Foreword
2. Introduction
3. 1. Getting Started
4. 1. 1.1. Installation
   2. 1.2. Hello, World!
   3. 1.3. Hello, Cargo!
5. 2. Programming a Guessing Game
6. 3. Common Programming Concepts
7. 1. 3.1. Variables and Mutability
   2. 3.2. Data Types
   3. 3.3. How Functions Work
   4. 3.4. Comments
   5. 3.5. Control Flow
8. 4. Understanding Ownership
9. 1. 4.1. What is Ownership?
   2. 4.2. References & Borrowing
   3. 4.3. Slices
10. 5. Using Structs to Structure Related Data
11. 1. 5.1. Defining and Instantiating Structs
    2. 5.2. An Example Program Using Structs
    3. 5.3. Method Syntax
12. 6. Enums and Pattern Matching
13. 1. 6.1. Defining an Enum
    2. 6.2. The match Control Flow Operator
    3. 6.3. Concise Control Flow with if let
14. 7. Packages, Crates, and Modules
15. 1. 7.1. Packages and crates for making libraries and executables
    2. 7.2. Modules and use to control scope and privacy
16. 8. Common Collections
17. 1. 8.1. Vectors
    2. 8.2. Strings
    3. 8.3. Hash Maps
18. 9. Error Handling
19. 1. 9.1. Unrecoverable Errors with panic!
    2. 9.2. Recoverable Errors with Result
    3. 9.3. To panic! or Not to panic!
20. 10. Generic Types, Traits, and Lifetimes
21. 1. 10.1. Generic Data Types
    2. 10.2. Traits: Defining Shared Behavior
    3. 10.3. Validating References with Lifetimes
22. 11. Testing
23. 1. 11.1. Writing tests
    2. 11.2. Running tests
    3. 11.3. Test Organization
24. 12. An I/O Project: Building a Command Line Program
25. 1. 12.1. Accepting Command Line Arguments
    2. 12.2. Reading a File
    3. 12.3. Refactoring to Improve Modularity and Error Handling
    4. 12.4. Developing the Library’s Functionality with Test Driven Development
    5. 12.5. Working with Environment Variables
    6. 12.6. Writing Error Messages to Standard Error Instead of Standard Output
26. 13. Functional Language Features: Iterators and Closures
27. 1. 13.1. Closures: Anonymous Functions that Can Capture Their Environment
    2. 13.2. Processing a Series of Items with Iterators
    3. 13.3. Improving Our I/O Project
    4. 13.4. Comparing Performance: Loops vs. Iterators
28. 14. More about Cargo and Crates.io
29. 1. 14.1. Customizing Builds with Release Profiles
    2. 14.2. Publishing a Crate to Crates.io
    3. 14.3. Cargo Workspaces
    4. 14.4. Installing Binaries from Crates.io with cargo install
    5. 14.5. Extending Cargo with Custom Commands
30. 15. Smart Pointers
31. 1. 15.1. Box<T> Points to Data on the Heap and Has a Known Size
    2. 15.2. The Deref Trait Allows Access to the Data Through a Reference
    3. 15.3. The Drop Trait Runs Code on Cleanup
    4. 15.4. Rc<T>, the Reference Counted Smart Pointer
    5. 15.5. RefCell<T> and the Interior Mutability Pattern
    6. 15.6. Creating Reference Cycles and Leaking Memory is Safe
32. 16. Fearless Concurrency
33. 1. 16.1. Threads
    2. 16.2. Message Passing
    3. 16.3. Shared State
    4. 16.4. Extensible Concurrency: Sync and Send
34. 17. Object Oriented Programming Features of Rust
35. 1. 17.1. Characteristics of Object-Oriented Languages
    2. 17.2. Using Trait Objects that Allow for Values of Different Types
    3. 17.3. Implementing an Object-Oriented Design Pattern
36. 18. Patterns Match the Structure of Values
37. 1. 18.1. All the Places Patterns May be Used
    2. 18.2. Refutability: Whether a Pattern Might Fail to Match
    3. 18.3. All the Pattern Syntax
38. 19. Advanced Features
39. 1. 19.1. Unsafe Rust
    2. 19.2. Advanced Lifetimes
    3. 19.3. Advanced Traits
    4. 19.4. Advanced Types
    5. 19.5. Advanced Functions & Closures
    6. 19.6. Macros
40. 20. Final Project: Building a Multithreaded Web Server
41. 1. 20.1. A Single Threaded Web Server
    2. 20.2. Turning our Single Threaded Server into a Multithreaded Server
    3. 20.3. Graceful Shutdown and Cleanup
42. 21. Appendix
43. 1. 21.1. A - Keywords
    2. 21.2. B - Operators and Symbols
    3. 21.3. C - Derivable Traits
    4. 21.4. D - Useful Development Tools
    5. 21.5. E - Editions
    6. 21.6. F - Translations
    7. 21.7. G - How Rust is Made and “Nightly Rust”