Rust learning tracks

One file, one function, and a clippy -D warnings gate that fails correct code. What the gate checks, how to read a rustc error, and why style violations are errors here.

Fluency with the compiler as teacher. Only Copy types appear — the "Rust behaves like C ints" model is installed deliberately so Track 2 can break it.

Single ownership in isolation. No & or &mut appears in this track and .clone() is explicitly permitted; every abstract claim is cashed out as a compiler error or a drop log.

&/&mut and aliasing XOR mutability. .clone() is withdrawn here — the training wheels come off. The borrow checker as a proof system, not a linter.

Model the domain so illegal states do not compile. Structs, enums, exhaustive match, newtypes and the builder — where the type system first does work you can feel.

Vec, HashMap, BTreeMap, the Entry API, and String vs &str vs bytes vs chars — plus enough iterator vocabulary to make Track 6 readable.

Replace exceptions with types: Option, Result, ? as a From conversion, error enums, Display/Error by hand, and when a panic is the correct answer.

Write code once for many types and name precisely the behaviour you depend on. The track that converts std's documentation from noise into a reference.

Wall 2. Elision first, then the annotations — the first 'a you write comes after you have met E0106 and read it as a question rather than a rejection.

How idiomatic Rust is actually written: Fn/FnMut/FnOnce, capture modes, adapters and custom iterators. Performance appears here for the first time — displayed, not graded.

Structure, encapsulation and verification. The generated main() sits outside your modules, so under-exposure fails to compile and over-exposure trips a lint — architecture, graded.

Box, Rc, RefCell, Weak, Deref, Cow — and the honest arena-vs-Rc<RefCell<_>> argument, taught arena-first so the interior-mutability cliff is a choice rather than a trap.

Heterogeneous collections and the four-way choice between generics, &dyn, Box<dyn> and enum dispatch — decided by measurement rather than folklore.

Performance becomes graded: a ratio band gates the solve. Allocation budgets, capacity, layout, cache behaviour and the measurements that separate a real win from noise.

Threads, scoped threads, channels, Mutex/RwLock, Arc and deadlock. Deliberately before async — async is a scheduling mechanism for concurrency, not a synonym for it.

Where a competent Rust programmer becomes a systems programmer: atomics, orderings, Send/Sync as auto traits — and an honest account of what cannot be observed without loom.

Wall 3. With no tokio available the executor lives in your own file, so Future, Waker, Pin and the async state machine stop being magic: you are the runtime.

Not "the escape hatch" but "the place you owe a proof": UB, raw pointers, invariants, unsafe as an audit obligation, and the safe abstractions that discharge it.

macro_rules!, the C boundary (libc is already linked, so FFI is problem-rich here), and making the compiler enforce your design instead of your documentation.

Write Rust a senior reviewer would sign off on, and reason honestly about what things cost. Multi-track capstones that need several earlier tracks at once.