Rust Programming Study Notes

Borrowing and References in Rust

How Rust lets code access data without taking ownership, using immutable and mutable references checked by the borrow checker.

Cargo and Crates in Rust

Understand Cargo, Rust's build system and package manager, and how crates and Cargo.toml/Cargo.lock manage dependencies.

Closures in Rust

Understand Rust closures, their capture modes, and the Fn, FnMut, and FnOnce traits that govern how they use captured variables.

Concurrency in Rust (Threads, Channels, Mutex)

Learn how Rust's ownership rules enable fearless concurrency using threads, channels, and mutexes with compile-time data race prevention.

Constants and Shadowing in Rust

Understand Rust constants declared with const and the concept of variable shadowing with let.

if let and while let in Rust

Simplify single-pattern matching in Rust using the concise if let and while let constructs.

Default Trait Implementations in Rust

Trait methods can provide a default body that implementers may use as-is or override with custom behavior.

Enums in Rust

Enums define a type by enumerating its possible variants, each of which can optionally hold its own data.

Error Handling in Rust (Result)

Learn how Rust models recoverable errors with the Result enum and the ? operator instead of exceptions.

Features of Rust

An overview of the core language features that make Rust safe, fast, and productive to use.

Functions in Rust

Learn how to declare, call, and return values from functions using Rust's fn syntax and expression-based return rules.

Generics in Rust

Generics let you write functions, structs, and enums that work over many types while remaining zero-cost at runtime.

HashMaps in Rust

HashMap<K, V> stores key-value pairs, giving fast average-case lookup by key at the cost of unordered iteration.

Higher-Order Functions and Iterators in Rust

Explore functions that take or return closures, the Iterator trait, and lazy adapters like map, filter, and fold.

History and Evolution of Rust

A look at how Rust originated at Mozilla Research and evolved into an independently governed language.

if-else Expressions in Rust

Learn how Rust's if-else works as an expression, requires bool conditions, and can return values directly.

Input and Output in Rust

Learn how to print output with println! and print!, and read user input using std::io in Rust.

Introduction to Rust Programming

A beginner-friendly overview of Rust, a systems programming language built for memory safety and speed.

Lifetimes in Rust

How Rust's lifetime annotations describe how long references remain valid, preventing dangling references at compile time.

Loops in Rust (loop, while, for)

Understand Rust's three loop constructs — loop, while, and for — and how loop can return a value with break.

match Expressions in Rust

Master Rust's exhaustive match expression for pattern matching on values, enums, tuples, and ranges.

Methods and impl Blocks in Rust

Learn how to attach behavior to structs and enums using impl blocks, self receivers, and associated functions.

Operator Overloading in Rust

Rust lets custom types support operators like + and - by implementing traits from std::ops.

Operators in Rust

Explore Rust's arithmetic, comparison, logical, and bitwise operators with practical examples.