🧭 Chapter 10 — Lessons Learned & What’s Next

“We rebuilt a wheel. now we understand axles, roads, and why it’s round.”

ownership at the metal: you must model who owns what at every instant.
three numbers rule: ptr, len, cap + strict invariants.
unsafe doesn’t mean unsound: with the right guards, you can recover safely from panics.
abstraction layering: RawVec (allocation) vs Vec (initialization & logic).
iteration & slices are borrow-projections: lift raw memory into safe references only when invariants guarantee correctness.

footgun	antidote
drop uninitialized memory	tie drops strictly to `[0..len)`
double-drop on `pop`/`into_iter`	use `ptr::read`, and consume/forget original owner
lost pointer on failed realloc	write to temp, only commit on success
panic mid-mutation	scope guards that roll back `len` and drop newly inited items
aliasing `&mut` during iteration	hand each slot out once, no overlap

You said your blog will also cover Box, Rc, NonNull, Unique, HashMap. here’s a crisp sequence and the promise of each:

Box<T> — Owning a Single Allocation
- Build minimal Box on top of alloc/dealloc.
- Move semantics, Box::leak, into_raw/from_raw.
- Niche optimization: ZSTs and non-null guarantees.
NonNull<T> — Raw Pointer With a Contract
- Why Option<NonNull<T>> is niche-optimized (no extra space).
- Using NonNull to encode “never null” and enable niche layouts.
- Powering custom containers without *mut T footguns.
Unique<T> (a la internal std concepts)
- Encoding unique ownership + provenance for aliasing rules.
- How this informs optimizer assumptions for Vec, Box.
Rc<T> — Shared Ownership & Refcounts
- Single-threaded refcounting; weak refs; cycle pitfalls.
- Layout: [refcnt][weakcnt][T] and pointer casting.
- Panic safety when cloning/decay to Weak.
HashMap<K,V> — Associative Power
- allocation + probing (Robin Hood / SwissTable sketch).
- Hash, BuildHasher, DoS safety.
- growth policy, tombstones, and rehashing guards.
- iterators over buckets and panic-safe rehash.

⚠️ each chapter will keep the same read-like sidenotes, warnings, and diagrams, with progressively richer invariants.

you didn’t just implement a vector — you built an intuition for why Rust’s safety model works and how to extend it beyond the standard library.

“unsafe is a scalpel — in careful hands, it heals.”

if you want, i can now spin this into publish-ready blog posts (mdx or markdown), including:

or we can start the next book in the series right away — which one do you want first: Box, NonNull, Unique, Rc, or HashMap?

Testing, Miri, and Final Checklist