Learn Rust

Write your first Rust program, understand the basic structure, and get comfortable with println!.

Learn how Rust handles variables: immutable by default, explicit mutation, shadowing, and constants.

Explore Rust's immutability, scalar types, String vs &str, shadowing, constants, and tuples.

Integers, floats, booleans, and characters — Rust's primitive building blocks.

Master println!, print!, debug formatting, number precision, and padding in Rust.

String slices and owned Strings, concatenation, formatting, and common string methods.

if/else expressions, loop, while, for — directing program execution in Rust.

Use loop, while, and for to repeat code and iterate in Rust.

Work with fixed-size arrays and slices in Rust.

Define and call functions, pass parameters, return values, and understand Rust's expression-based returns.

Store and look up key-value pairs with std::collections::HashMap.

Move semantics, the Copy trait, clone, and how Rust manages memory without a garbage collector.

Borrow values with & references. Understand mutable borrows and the rules that prevent data races.

Understand ownership, borrowing, and references in Rust.

View parts of arrays and strings without copying. Understanding &[T] and &str.

Define custom data types, add methods with impl, and use associated functions as constructors.

Define enums with data, use Option to represent nullable values, and avoid null pointer bugs.

Add methods to structs with impl blocks.

Define shared behavior with traits and implement them for types.

master match expressions, destructuring, guards, and the @ binding operator.

Vec<T> — Rust's growable array. Create, modify, iterate, and transform vectors.

Store key-value pairs with HashMap. Insert, lookup, update, and iterate.

Organize code into modules and use the standard library.

Result<T,E> for recoverable errors, the ? operator, and when to use panic vs Result.

Define shared behaviour with traits, implement them for your types, and use trait bounds.

Write code that works for multiple types with generic functions, structs, and enums.

Make HTTP requests using reqwest or std library basics.

Anonymous functions that capture their environment. Fn, FnMut, FnOnce traits.

Parse and serialize JSON with serde_json or manual string building.

The Iterator trait, lazy evaluation, map/filter/fold, and writing your own iterator.

Use iterators, closures, and iterator adapters (map, filter, collect).

Organise code with mod, control visibility with pub, and use the use keyword.

Lifetime annotations, the borrow checker, and why Rust needs lifetime parameters.

Box<T> for heap allocation, Rc<T> for shared ownership, and RefCell<T> for interior mutability.

Spawn threads, share data with Arc and Mutex, and pass messages with channels.

Write unit tests with #[test], use assert macros, and organise tests in Rust.

Read and write files with std::fs, handle errors with Result, and work with paths.