Learn Rust

Install Rust with rustup, create a project with cargo new, and build and run it with cargo run.

Bind values with let, opt into mutation with mut, and use shadowing and const where they fit.

Integers, floats, bool and char, plus tuples and fixed-size arrays, and how Rust handles overflow and conversions.

Declare functions with typed parameters and return values, and understand why almost everything in Rust is an expression.

Branch with if, repeat with loop, while and for over ranges, and use labels and break values.

Every value has one owner; assignment moves ownership, and the value is freed when its owner goes out of scope.

Lend access with & and &mut references, and learn the rule: many readers or one writer, never both.

Borrow part of an array, Vec or String as a slice (&[T] or &str) and write functions that accept any of them.

Group named fields into a struct, attach methods and associated functions in impl blocks, and pick the right self.

Model values that can be one of several variants, each with its own data, and handle every case with match.

Represent a value that may be absent with Option<T>, and unpack it with match, if let, let-else and combinators.

Use patterns everywhere: destructure structs and tuples, add guards, match ranges, and bind with @.

Return Result<T, E> from fallible functions and propagate errors with ?, keeping panics for bugs.

Store a growable list in Vec<T>: create, push, index safely, iterate, and understand capacity.

Work with owned String and borrowed &str, build and format text, and handle UTF-8 correctly.

Store key-value pairs in HashMap, update counts and groups with the entry API, and know when to use BTreeMap or HashSet.

Design error types with std::error::Error, derive them with thiserror in libraries, and add context with anyhow in applications.

Organise code into modules and files, control visibility with pub, and add dependencies in Cargo.toml.

Write unit tests with #[test] and assert macros, integration tests in tests/, doc tests, and run them with cargo test.

Define shared behaviour with traits, implement them for your types, and use default methods and impl Trait parameters.

Write functions and types over any T, constrain T with trait bounds and where clauses, and know what monomorphization costs.

Know Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, Default, Display and From/Into, and when to derive or implement them.

Write anonymous functions that capture their environment, understand Fn, FnMut and FnOnce, and use move closures.

Chain lazy iterator adapters like map, filter and enumerate, finish with collect, sum or fold, and implement Iterator.

Use dyn Trait for runtime polymorphism, understand vtables and fat pointers, and know the dyn-compatibility rules.

Read and write lifetime parameters like 'a that tell the compiler how returned references relate to inputs.

Put values on the heap with Box, share ownership with Rc, and mutate shared data with RefCell.

Outlives bounds, what T: 'static really means, higher-ranked bounds, and how impl Trait captures lifetimes in Rust 2024.

Mutate through shared references safely with Cell, RefCell, OnceCell and LazyLock, and see how UnsafeCell underpins them all.

Spawn OS threads, move data into them, join their results, and borrow local data safely with thread::scope.

Share data across threads with Arc, guard mutation with Mutex or RwLock, use atomics for counters, and avoid deadlocks.

Send values between threads with mpsc channels, use bounded channels for backpressure, and shut down cleanly.

Understand what async fn returns, why futures are lazy, how executors poll them, and when async beats threads.

Run async code on the Tokio runtime: #[tokio::main], spawn, join!, select!, timeouts, async channels and spawn_blocking.

The auto traits that make data races impossible: what Send and Sync mean, which std types lack them, and when to implement them unsafely.

Why async state machines can't move, what Pin and Unpin guarantee, how to pin with Box::pin and pin!, and how pin projection works.

Write macro_rules! macros with fragment specifiers and repetitions, understand hygiene, and export them from a crate.

What unsafe unlocks, raw pointers and &raw, writing sound safe abstractions, SAFETY comments, the 2024 edition rules and Miri.

How Rust lays out structs and enums: size and alignment, field reordering, repr(C), repr(transparent), niche optimisation and DSTs.

How lifetimes subtype, why &mut T is invariant, and how PhantomData declares ownership, variance and auto traits for unused type parameters.

Write derive, attribute and function-like procedural macros with proc_macro, syn and quote, with good error spans.

Declare foreign functions in unsafe extern blocks, export extern "C" functions, pass strings, structs and callbacks, and keep ownership straight.