Rust learning tracks

Get started with Rust exercises. Learn how compilation, tests and Clippy checks work, and how to use their feedback to improve a solution.

Practise values, primitive types, expressions, branching and loops. Read compiler messages and learn how Rust handles conversions and arithmetic.

Follow values as they move, copy, clone and drop. Use compiler errors and destruction logs to understand who owns each value.

Use shared and mutable references to work with data without taking ownership. Learn to resolve conflicting borrows and choose appropriate function signatures.

Represent data with structs and enums, handle cases with pattern matching, and use newtypes and builders to express constraints.

Work with vectors, maps and strings. Choose collection operations, handle UTF-8 text, and use iterators to process values.

Handle missing values and failures with Option and Result. Propagate errors with ?, define useful error types, and decide when a panic is appropriate.

Write reusable functions and types with generics, trait bounds and associated types. Learn to read and express the requirements of an API.

Return borrowed data safely. Start with lifetime elision, then add annotations where needed to describe relationships between inputs, outputs and stored references.

Use closures and iterator adapters to transform data. Explore captures, the Fn traits, lazy evaluation and custom iterator implementations.

Organize code into modules, choose public interfaces, and write tests and documentation that help callers use your code correctly.

Choose between owned, shared and borrowed data using Box, Rc, Weak, RefCell and Cow. Compare runtime borrow checks with arena-based designs.

Work with values of different concrete types through shared interfaces. Compare generics, trait objects and enums, including their ownership and dispatch tradeoffs.

Investigate allocations, capacity, data layout and cache behavior. Measure changes and interpret the runtime or allocation checks used by individual exercises.

Coordinate threads with channels, shared ownership and locks. Practise scoped threads, handle worker failures, and recognize deadlock risks.

Explore atomic operations, memory ordering and the Send and Sync traits. Learn what tests can reveal and where concurrency reasoning needs stronger tools.

Build small futures and executors to understand polling, waking and pinning. Trace how asynchronous work makes progress without assuming a full runtime library.

Work through raw pointers, memory invariants and undefined behavior. Learn what an unsafe operation requires and how a safe interface must uphold those requirements.

Generate code with declarative macros, call C interfaces, and use types to express API constraints. Learn the limits and responsibilities of each approach.

Combine earlier skills in larger exercises. Review ownership choices, API design and performance tradeoffs, then explain why your solution fits its requirements.