PART 3 - The Heart of Rust

This part is the center of the handbook.

If you understand Part 3 deeply, the rest of Rust stops looking like a list of disconnected rules. Traits make sense. Async makes sense. Smart pointers make sense. Even many compiler errors stop feeling arbitrary. If you do not understand Part 3, the rest of the language becomes a series of local tricks and workarounds.

The core claim of this part is simple:

ownership, borrowing, lifetimes, moves, Copy, Clone, Drop, stack versus heap, and the borrow checker are not separate topics. They are one resource model seen from different angles.

Chapters in This Part

• Chapter 16: Ownership as Resource Management
• Chapter 17: Borrowing, Constrained Access
• Chapter 18: Lifetimes, Relationships Not Durations
• Chapter 19: Stack vs Heap, Where Data Lives
• Chapter 20: Move Semantics, Copy, Clone, and Drop
• Chapter 21: The Borrow Checker, How the Compiler Thinks

Part 3 Summary

Ownership is Rust’s resource model. Borrowing is Rust’s access model. Lifetimes are Rust’s borrowed-relationship model. Moves, Copy, Clone, and Drop are lifecycle events inside that model. Stack versus heap explains the physical representation underneath it. The borrow checker is the compiler enforcing all of it over control flow.

These are not six topics. They are one coherent design. Once you see that coherence, Rust stops feeling like a language of special cases and starts feeling like a language with one deep rule taught through many surfaces.