Rust — Basics to Advanced

// Variables are IMMUTABLE by default — a core safety feature let x = 5; // immutable — cannot reassign let mut y = 5; // mutable — can reassign y = 10; // OK // x = 10; // ERROR: cannot assign twice to immutable variable // Shadowing — rebind the same name (creates a NEW variable) let z = 5; let z = z + 1; // new z shadows old z. Value: 6 let z = "now a string"; // shadowing can even change the type! // Shadowing != mut: mut keeps the type, shadowing can change it // Constants — always immutable, type annotation required, compile-time value const MAX_POINTS: u32 = 100_000; // _ is visual separator // Cannot use runtime values in const — must be a literal or const expression // Static — single memory address for program lifetime static GREETING: &str = "Hello"; // 'static lifetime, stored in binary static mut COUNTER: u32 = 0; // mutable static — requires unsafe to access

// fn keyword, snake_case names, type annotations required on params fn add(x: i32, y: i32) -> i32 { x + y // no semicolon = expression = implicit return value } // Explicit return — only needed for early returns fn safe_divide(a: f64, b: f64) -> Option<f64> { if b == 0.0 { return None; } // early return Some(a / b) // implicit return } // Unit type () is the default return — Rust's "void" fn greet(name: &str) { // implicitly -> () println!("Hello, {}!", name); } // Statements vs Expressions — fundamental distinction in Rust // Statement: performs action, no value, ends with semicolon // Expression: evaluates to a value, no semicolon let y = { // block is an expression let x = 3; x + 1 // last line without ; = value of block }; // y = 4 // Adding ; to last line makes it a statement — block evaluates to ()

// if is an expression — use in let bindings let num = 7; let label = if num % 2 == 0 { "even" } else { "odd" }; // Both arms must return the same type! // loop — infinite, use break to exit (can return a value) let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } // returns 20 }; // Labeled loops — break/continue specific outer loop 'outer: for i in 0..5 { for j in 0..5 { if i + j == 6 { break 'outer; } } } // while let mut n = 3; while n != 0 { println!("{}!", n); n -= 1; } // for — idiomatic Rust, always use over while for iteration for i in 0..5 { print!("{} ", i); } // 0 1 2 3 4 (exclusive) for i in 0..=5 { print!("{} ", i); } // 0 1 2 3 4 5 (inclusive) for item in &vec { println!("{}", item); } for (i, v) in vec.iter().enumerate() { println!("{}: {}", i, v); } // match — exhaustive pattern matching (compiler checks all cases) let x = 5u32; match x { 1 => println!("one"), 2 | 3 => println!("two or three"), // OR patterns 4..=9 => println!("four to nine"), // range pattern n if n % 2 == 0 => println!("even: {}", n), // match guard _ => println!("something else"), // wildcard — must cover rest } // if let — concise single-pattern match if let Some(val) = some_option { println!("got: {}", val); } // while let — loop while pattern matches while let Some(top) = stack.pop() { println!("{}", top); }

// Rule 1: Every value has exactly ONE owner let s1 = String::from("hello"); // s1 owns this String on the heap // Rule 2: Only one owner at a time — assignment MOVES ownership let s2 = s1; // s1 is MOVED to s2. s1 is now invalid! // println!("{}", s1); // ERROR: value borrowed after move println!("{}", s2); // OK // Rule 3: When owner goes out of scope, value is DROPPED (memory freed) { let s3 = String::from("world"); } // s3 goes out of scope → drop() called → heap memory freed automatically // Clone: explicit deep copy — duplicates heap data let s1 = String::from("hello"); let s2 = s1.clone(); // BOTH s1 and s2 are valid, independent copies println!("{} and {}", s1, s2); // Copy types (stack-only, no destructor): i32, f64, bool, char, tuples of Copy // These are COPIED, not moved — both variables remain valid let x = 5; let y = x; // Copy — x is still valid println!("{} and {}", x, y); // OK // Functions behave like assignment — they take ownership or copy fn takes_ownership(s: String) { println!("{}", s); } // s dropped here fn makes_copy(n: i32) { println!("{}", n); } // i32 is Copy let s = String::from("hello"); takes_ownership(s); // s moved into function // println!("{}", s); // ERROR: s was moved let n = 5; makes_copy(n); // n is copied println!("{}", n); // OK — Copy type

// &T — immutable reference. Borrow without taking ownership. fn length(s: &String) -> usize { s.len() } // borrows s, does not own it let s = String::from("hello"); let len = length(&s); // pass reference — s is NOT moved println!("{} has {} chars", s, len); // s still valid! // &mut T — mutable reference. Borrow AND allow modification. fn push_world(s: &mut String) { s.push_str(", world"); } let mut s = String::from("hello"); // must be mut to create &mut push_world(&mut s); println!("{}", s); // "hello, world" // BORROW RULES — enforced at compile time: // RULE A: ONE &mut OR any number of & — NEVER both at same time let mut s = String::from("hello"); let r1 = &s; // OK let r2 = &s; // OK — multiple immutable refs allowed // let r3 = &mut s; // ERROR: cannot borrow mutably while immutably borrowed println!("{} {}", r1, r2); // r1, r2 last used here — borrows END here (NLL) let r3 = &mut s; // OK now — r1 and r2 are no longer in scope r3.push('!'); // RULE B: References must NOT outlive the value they point to // fn dangle() -> &String { // ERROR // let s = String::from("hi"); // &s // s is dropped at end of scope — reference would dangle! // } // solution: return String (transfer ownership) instead of &String

// Named-field struct struct User { username: String, email: String, age: u32, active: bool, } // Instantiation — order doesn't matter, but all fields required let user1 = User { username: String::from("alice"), email: String::from("alice@example.com"), age: 30, active: true, }; // Field shorthand — when variable name matches field name let username = String::from("bob"); let user2 = User { username, email: String::from("bob@b.com"), age: 25, active: true }; // Struct update syntax — copy remaining fields from another instance let user3 = User { email: String::from("carol@c.com"), ..user1 // NOTE: String fields are MOVED from user1 — user1.email no longer valid }; // Tuple struct — named tuple type struct Color(u8, u8, u8); struct Point(f64, f64, f64); let red = Color(255, 0, 0); println!("{}", red.0); // access by index // Unit struct — no fields; useful for implementing traits struct Sentinel; // Methods via impl block impl User { // Associated function (no self) — constructor pattern fn new(username: String, email: String) -> Self { Self { username, email, age: 0, active: true } } fn is_active(&self) -> bool { self.active } // immutable borrow fn deactivate(&mut self) { self.active = false; } // mutable borrow fn into_email(self) -> String { self.email } // takes ownership } let mut u = User::new(String::from("dan"), String::from("dan@d.com")); u.deactivate(); // Rust auto-borrows: sugar for User::deactivate(&mut u) println!("{}", u.is_active()); // false

// Each variant can hold DIFFERENT types and amounts of data enum Message { Quit, // unit variant — no data Move { x: i32, y: i32 }, // struct-like variant Write(String), // single value ChangeColor(u8, u8, u8), // tuple variant } impl Message { fn call(&self) { match self { Message::Quit => println!("Quit"), Message::Move { x, y } => println!("Move to {},{}", x, y), Message::Write(s) => println!("Write: {}", s), Message::ChangeColor(r, g, b) => println!("Color: {},{},{}", r, g, b), } } } // Option<T> — built-in nullable type. No null in safe Rust! // enum Option<T> { Some(T), None } let five: Option<i32> = Some(5); let absent: Option<i32> = None; // MUST unwrap before using — forces you to handle the None case let n = five.unwrap_or(0); // default if None let n = five.unwrap_or_default(); // type's Default value let doubled = five.map(|n| n * 2); // transform the inner value: Some(10) if let Some(val) = five { println!("{}", val); } // Pattern matching — exhaustive match five { Some(n) if n > 0 => println!("positive: {}", n), // guard Some(n) => println!("non-positive: {}", n), None => println!("nothing"), }

// Destructuring structs struct Point { x: i32, y: i32 } let p = Point { x: 3, y: 7 }; let Point { x, y } = p; // x=3, y=7 // Destructuring with rename let Point { x: px, y: py } = p; // Ignore fields let Point { x, .. } = p; // ignore y // @ bindings — bind a value while also testing it match age { n @ 0..=17 => println!("minor, age {}", n), n @ 18..=64 => println!("adult, age {}", n), n => println!("senior, age {}", n), } // Tuple patterns match (x, y) { (0, 0) => println!("origin"), (x, 0) => println!("on x-axis at {}", x), (0, y) => println!("on y-axis at {}", y), (x, y) => println!("({}, {})", x, y), } // Nested enum patterns enum Color { Rgb(u8,u8,u8), Hsv(u16,u8,u8) } enum Shape { Circle { radius: f64, color: Color }, Square(f64) } match shape { Shape::Circle { radius, color: Color::Rgb(r,g,b) } => println!("Circle r={} rgb({},{},{})", radius, r, g, b), Shape::Circle { radius, color: Color::Hsv(..) } => println!("HSV circle, r={}", radius), Shape::Square(side) => println!("Square side={}", side), }

// Result<T, E> is the primary error type in Rust // enum Result<T, E> { Ok(T), Err(E) } use std::fs; use std::io; // The ? operator — propagate errors without boilerplate fn read_username(path: &str) -> Result<String, io::Error> { let s = fs::read_to_string(path)?; // ? = return Err early if error, else unwrap Ok Ok(s.trim().to_string()) } // ? desugars to: // match fs::read_to_string(path) { // Ok(val) => val, // Err(e) => return Err(e.into()), // .into() converts error type // } // Chaining ? elegantly fn process(path: &str) -> Result<Vec<i32>, Box<dyn std::error::Error>> { let content = fs::read_to_string(path)?; let nums: Vec<i32> = content .lines() .map(|l| l.trim().parse::<i32>()) .collect::<Result<Vec<_>, _>>()?; // collect into Result Ok(nums) } // Common Result methods result.is_ok(); result.is_err(); result.unwrap() // panics on Err — tests/prototypes only result.expect("custom message") // panics with message result.unwrap_or(default_val) // default if Err result.unwrap_or_else(|e| handle(e)) result.map(|v| transform(v)) // transform Ok value, pass Err through result.map_err(|e| convert(e)) // transform Err value result.and_then(|v| next(v)) // chain — flatMap for Result result.or_else(|e| recover(e)) // recover from Err result.ok() // convert to Option (drops error info)

// Method 1: thiserror — derive macro for library error types use thiserror::Error; #[derive(Error, Debug)] enum AppError { #[error("IO error: {0}")] Io(#[from] std::io::Error), // #[from] auto-impl From<io::Error> #[error("Parse error: {0}")] Parse(#[from] std::num::ParseIntError), #[error("config value {value} is out of range {min}..={max}")] OutOfRange { value: i32, min: i32, max: i32 }, #[error("unknown error")] Unknown, } // ? now works across error types automatically fn load_config(path: &str) -> Result<i32, AppError> { let s = std::fs::read_to_string(path)?; // io::Error → AppError::Io via From let n: i32 = s.trim().parse()?; // ParseIntError → AppError::Parse if n < 0 || n > 100 { return Err(AppError::OutOfRange { value: n, min: 0, max: 100 }); } Ok(n) } // Method 2: anyhow — type-erased errors for application code use anyhow::{Context, Result, bail, ensure}; fn run() -> Result<()> { // anyhow::Result hides the error type let s = std::fs::read_to_string("config.txt") .context("failed to read config.txt")?; // adds context to any error let n: i32 = s.trim().parse() .context("config must be an integer")?; ensure!(n > 0, "value must be positive, got {}", n); // returns Err if false if n > 1000 { bail!("value {} too large (max 1000)", n); } // early return Err println!("config: {}", n); Ok(()) } // Idiom: use thiserror in libraries, anyhow in binaries/applications

// Define a trait — shared interface across types trait Animal { fn name(&self) -> &str; fn sound(&self) -> String; // Default implementation — can be overridden fn describe(&self) -> String { format!("{} says {}", self.name(), self.sound()) } } struct Dog { name: String } struct Cat { name: String } impl Animal for Dog { fn name(&self) -> &str { &self.name } fn sound(&self) -> String { String::from("woof") } } impl Animal for Cat { fn name(&self) -> &str { &self.name } fn sound(&self) -> String { String::from("meow") } // describe() uses default implementation } // Trait bounds — static dispatch (monomorphized, zero overhead) fn print_animal(a: &impl Animal) { println!("{}", a.describe()); } // Equivalent longer form (trait bound syntax): fn print_animal<A: Animal>(a: &A) { println!("{}", a.describe()); } // Multiple bounds fn print_and_debug<T: Animal + std::fmt::Debug>(a: &T) { println!("{:?}", a); println!("{}", a.describe()); } // Where clause — cleaner for complex bounds fn compare<T, U>(t: &T, u: &U) where T: Animal + Clone, U: Animal + std::fmt::Display, { /* ... */ } // Return impl Trait — caller doesn't know concrete type fn make_animal() -> impl Animal { Dog { name: String::from("Rex") } } // Return dyn Trait — type erased, heap-allocated, runtime dispatch fn make_animal_dyn(is_dog: bool) -> Box<dyn Animal> { if is_dog { Box::new(Dog { name: String::from("Rex") }) } else { Box::new(Cat { name: String::from("Whiskers") }) } } // Use dyn Trait when you need DIFFERENT concrete types at runtime

// Generic function — works for any T that satisfies the bound fn largest<T: PartialOrd>(list: &[T]) -> &T { let mut largest = &list[0]; for item in list { if item > largest { largest = item; } } largest } println!("{}", largest(&[34, 50, 25, 100, 65])); // 100 println!("{}", largest(&[1.5, 2.7, 0.3])); // 2.7 // Generic struct struct Stack<T> { items: Vec<T> } impl<T> Stack<T> { fn new() -> Self { Stack { items: Vec::new() } } fn push(&mut self, item: T) { self.items.push(item); } fn pop(&mut self) -> Option<T> { self.items.pop() } fn peek(&self) -> Option<&T> { self.items.last() } fn is_empty(&self) -> bool { self.items.is_empty() } } // Conditional impl — only add method when T meets extra bound impl<T: std::fmt::Display> Stack<T> { fn print_top(&self) { match self.peek() { Some(t) => println!("top: {}", t), None => println!("stack is empty"), } } } // Important derive macros (auto-implement common traits) #[derive(Debug, Clone, PartialEq, Eq, Hash, Default)] struct Point { x: i32, y: i32 } // Debug: {:?} printing Clone: .clone() PartialEq: == // Eq: stricter equality Hash: use as HashMap key Default: Point::default()

// Vec<T> — growable heap array (use most often) let mut v: Vec<i32> = Vec::new(); let mut v = vec![1, 2, 3, 4, 5]; // macro shorthand v.push(6); // O(1) amortized v.pop(); // Option<T> v.insert(1, 10); // insert at index — O(n) v.remove(1); // remove at index — O(n) v.len(); v.is_empty(); v.capacity(); v[0]; // panics if out of bounds v.get(0); // Option<&T> — safe indexing v.contains(&3); v.sort(); v.sort_by(|a,b| b.cmp(a)); v.sort_by_key(|k| k.abs()); v.dedup(); // remove consecutive duplicates (sort first) v.retain(|&x| x % 2 == 0); // keep only even numbers in-place v.extend([7, 8, 9]); // append slice v.truncate(3); // keep only first 3 v.clear(); // remove all // HashMap<K, V> — hash table, O(1) average get/set use std::collections::HashMap; let mut map: HashMap<String, i32> = HashMap::new(); map.insert(String::from("Alice"), 100); map.insert(String::from("Bob"), 90); map.get("Alice"); // Option<&V> map.contains_key("Bob"); map.remove("Bob"); // Option<V> map.len(); map.is_empty(); // Entry API — idiomatic insert-if-absent map.entry(String::from("Carol")).or_insert(0); // insert 0 if absent *map.entry(String::from("Alice")).or_insert(0) += 1; // increment or init for (key, val) in &map { println!("{}: {}", key, val); } // HashSet<T> — unique values, O(1) contains use std::collections::HashSet; let mut set: HashSet<i32> = HashSet::new(); set.insert(1); set.insert(2); set.insert(1); // {1, 2} — no duplicates set.contains(&1); set.remove(&1); let a: HashSet<_> = [1,2,3].iter().collect(); let b: HashSet<_> = [2,3,4].iter().collect(); let union: HashSet<_> = a.union(&b).collect(); // {1,2,3,4} let intersection: HashSet<_> = a.intersection(&b).collect(); // {2,3} let difference: HashSet<_> = a.difference(&b).collect(); // {1} // Other collections: // BTreeMap<K,V> — sorted map (use when iteration order matters) // VecDeque<T> — double-ended queue (fast push/pop from both ends) // BinaryHeap<T> — max-heap priority queue // LinkedList<T> — rarely used — Vec is usually faster

// Iterator trait — produces values lazily // trait Iterator { type Item; fn next(&mut self) -> Option<Self::Item>; } let v = vec![1, 2, 3, 4, 5, 6]; // Three iteration modes for x in v.iter() { /* &T — borrows */ } for x in v.iter_mut() { /* &mut T — mutable borrow */ } for x in v.into_iter() { /* T — takes ownership, v unusable after */ } for x in &v { /* &T — sugar for v.iter() */ } for x in &mut v { /* &mut T — sugar for v.iter_mut() */ } // Adapters — lazy, return new iterators (nothing runs yet) let result: Vec<i32> = v.iter() .filter(|&&x| x % 2 == 0) // keep: 2, 4, 6 .map(|&x| x * x) // square: 4, 16, 36 .take(2) // first 2: 4, 16 .collect(); // NOW it runs! [4, 16] // Common adapters iter.map(|x| transform(x)) iter.filter(|x| predicate(x)) iter.filter_map(|x| maybe(x)) // filter + map in one — removes None iter.take(n) // first n elements iter.skip(n) // skip first n iter.enumerate() // (usize, T) pairs iter.zip(other) // pair with another iterator iter.chain(other) // append another iterator iter.flat_map(|x| iter_of(x)) // map then flatten one level iter.flatten() // flatten one level of nesting iter.cloned() // &T → T by cloning iter.copied() // &T → T for Copy types iter.rev() // reverse (requires DoubleEndedIterator) iter.peekable() // peek() without consuming iter.step_by(n) // every nth element iter.windows(n) // overlapping windows of size n iter.chunks(n) // non-overlapping chunks // Consumers — run the pipeline, produce a final value iter.collect::<Vec<_>>() // into Vec, HashMap, HashSet, String, ... iter.sum::<i32>() // sum all iter.product::<i32>() // multiply all iter.count() // number of elements iter.max(); iter.min() // Option<T> iter.max_by_key(|x| key(x)) // max by a derived key iter.any(|x| condition(x)) // true if any match (short-circuits) iter.all(|x| condition(x)) // true if all match (short-circuits) iter.find(|x| condition(x)) // Option<&T> — first match iter.position(|x| cond(x)) // Option<usize> — index of first match iter.fold(init, |acc, x| f(acc, x)) // general reduction iter.for_each(|x| action(x)) // run side effect on each iter.last() // Option<T> — consume all, return last iter.nth(n) // Option<T> — nth element (0-indexed) iter.unzip() // Vec of (A,B) → (Vec<A>, Vec<B>) iter.partition(|x| cond(x)) // split into (Vec matching, Vec not) // Custom iterator struct Fibonacci { a: u64, b: u64 } impl Iterator for Fibonacci { type Item = u64; fn next(&mut self) -> Option<u64> { let next = self.a + self.b; self.a = self.b; self.b = next; Some(self.a) // infinite iterator — never returns None } } let fibs: Vec<u64> = Fibonacci { a: 0, b: 1 }.take(10).collect(); // Custom iterator gets ALL adapter methods for free!

// Closure syntax — | params | body let add = |x, y| x + y; // types inferred let add = |x: i32, y: i32| -> i32 { x + y }; // explicit types let double = |x| x * 2; println!("{}", double(5)); // 10 // Closures CAPTURE their environment — functions cannot let threshold = 10; let is_big = |n| n > threshold; // captures threshold by reference println!("{}", is_big(15)); // true // The three closure traits — how the closure uses captured values: // // Fn — captures by reference (&T) — can call many times // FnMut — captures by mutable reference (&mut T) — can call many times, may mutate // FnOnce — captures by value (T) — can call only ONCE (consumes captured values) // // Every closure implements FnOnce; closures that don't move implement FnMut; // closures that don't mutate also implement Fn. Fn ⊂ FnMut ⊂ FnOnce // FnMut example let mut count = 0; let mut increment = || { count += 1; count }; // mutably borrows count println!("{}", increment()); // 1 println!("{}", increment()); // 2 // FnOnce example — can only call once let name = String::from("Alice"); let greet = move || { println!("Hello, {}!", name); // name is MOVED into closure drop(name); // explicitly consume — makes it FnOnce }; greet(); // OK — consumes name // greet(); // ERROR: closure was already called and consumed name // move keyword — force ownership transfer into closure let s = String::from("data"); let f = move || println!("{}", s); // s moved into f — required for threads // s is no longer accessible here std::thread::spawn(f); // thread may outlive s — move ensures it owns it // Closures as parameters — generic over Fn trait fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 { f(x) } fn apply_mut<F: FnMut() -> i32>(mut f: F) -> i32 { f() } fn apply_once<F: FnOnce() -> String>(f: F) -> String { f() } // Store closure in struct — use Box<dyn Fn> for type erasure struct Handler { callback: Box<dyn Fn(i32) -> i32> } impl Handler { fn new(f: impl Fn(i32) -> i32 + 'static) -> Self { Self { callback: Box::new(f) } } fn run(&self, x: i32) -> i32 { (self.callback)(x) } }

// When do you need lifetime annotations? // When a function takes MULTIPLE references and returns a reference — // the compiler doesn't know which input the output is tied to. // 'a is a lifetime parameter — reads as "lifetime a" fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() >= y.len() { x } else { y } } // 'a = the SHORTER of x and y's lifetimes — result valid as long as both inputs let result; { let s1 = String::from("long string"); let s2 = String::from("xyz"); result = longest(s1.as_str(), s2.as_str()); println!("{}", result); // OK — both s1 and s2 still alive } // println!("{}", result); // ERROR — s1, s2 dropped, result would dangle // Lifetime in structs — struct cannot outlive the reference it holds struct Important<'a> { content: &'a str, // Important holds a borrowed string slice } impl<'a> Important<'a> { fn announce(&self) -> &str { self.content } // lifetime elided — OK here } let novel = String::from("Call me Ishmael. Some years ago..."); let first_sentence = novel.split('.').next().expect("no period"); let i = Important { content: first_sentence }; // i cannot outlive novel // Static lifetime — reference valid for entire program duration let s: &'static str = "I live forever"; // string literals are 'static

// Rust infers lifetimes using 3 elision rules. // You only annotate when rules don't resolve all lifetimes. // Rule 1: Each reference parameter gets its own lifetime fn foo(x: &str) -> &str { x } // Expands to: fn foo<'a>(x: &'a str) -> &'a str fn bar(x: &str, y: &str) -> &str { x } // ERROR — ambiguous which input // Must write: fn bar<'a>(x: &'a str, y: &str) -> &'a str { x } // Rule 2: If exactly one input reference, output gets same lifetime fn first_word(s: &str) -> &str { // no annotation needed let bytes = s.as_bytes(); for (i, &byte) in bytes.iter().enumerate() { if byte == b' ' { return &s[..i]; } } &s[..] } // Rule 3: If &self or &mut self, output gets self's lifetime impl Important<'_> { fn level(&self) -> &str { self.content } // no annotation needed } // Higher-Ranked Trait Bounds (HRTB) — "for any lifetime 'a" fn apply_to_str<F>(f: F) -> String where F: for<'a> Fn(&'a str) -> &'a str, // works for any lifetime { f("hello").to_string() } // Variance — how lifetime relationships work in subtyping: // Covariant: &'long T can be used where &'short T expected (safe — longer is stricter) // Invariant: &'a mut T is invariant over T — must match exactly (prevents aliasing bugs) // Contravariant: fn(T) — argument types are contravariant

// The Mental Model: The State Machine Transformation // When you write: async fn example() { let a = step_one().await; let b = step_two(a).await; } // The compiler transforms it into an internal Enum: enum ExampleFuture { State0, // Initial state State1 { a: ResultType }, // Waiting for step_one State2 { b: FinalType }, // Waiting for step_two Done, // Completed } // Why this matters: // 1. No stack frames: Unlike OS threads, futures don't need a massive stack. // 2. Cooperative: The task gives up control (yields) at every .await point. // 3. Lazy: If you don't poll the state machine, it never moves. // async fn returns an impl Future — a lazy state machine // Nothing runs until the future is polled by an executor async fn fetch_data(url: &str) -> Result<String, reqwest::Error> { let response = reqwest::get(url).await?; // .await = poll until ready let text = response.text().await?; Ok(text) } // async fn desugars to a state machine enum: // State0: before first .await // State1: after first .await, waiting for second // State2: done // The compiler generates this automatically // Futures are LAZY — you must .await them or they do nothing let f = fetch_data("https://example.com"); // not executed yet! let result = f.await; // NOW it runs // Tokio — the most popular async runtime // Add to Cargo.toml: tokio = { version = "1", features = ["full"] } #[tokio::main] // macro that creates the Tokio runtime and calls your async main async fn main() { let result = fetch_data("https://api.example.com/data").await; match result { Ok(data) => println!("{}", data), Err(e) => eprintln!("Error: {}", e), } } // Spawn a task — runs concurrently, like a goroutine let handle = tokio::spawn(async move { fetch_data("https://example.com").await }); let result = handle.await?; // JoinHandle returns Result (task may panic) // Run multiple futures CONCURRENTLY (not parallel — same thread unless spawned) let (r1, r2) = tokio::join!( fetch_data("https://api.example.com/a"), fetch_data("https://api.example.com/b"), ); // both run concurrently, wait for both // Race futures — first to complete wins tokio::select! { result = fetch_data("https://fast.example.com") => println!("fast: {:?}", result), result = fetch_data("https://slow.example.com") => println!("slow: {:?}", result), _ = tokio::time::sleep(std::time::Duration::from_secs(5)) => println!("timeout!"), }

// Why Pin exists: // async state machines can be self-referential (State1 holds a ref to State0's data) // If the future is moved in memory, internal pointers become dangling // Pin<P> guarantees the pointee will NOT be moved after pinning use std::pin::Pin; use std::task::{Context, Poll}; use std::future::Future; // The Future trait — what the executor calls pub trait Future { type Output; fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>; } // Poll::Ready(value) — done, return value // Poll::Pending — not ready, future has registered a Waker // When a future returns Pending, it MUST register cx.waker() // When the event is ready (I/O, timer), Waker::wake() is called // The executor then re-polls the future // Pinning in practice: let future = fetch_data("https://example.com"); let pinned = Box::pin(future); // heap-pin — stable address tokio::spawn(pinned); // pin! macro — stack pinning (avoids heap allocation) tokio::pin!(future); future.await;

// 1. Dereference raw pointers (*const T, *mut T) let x = 42i32; let r1 = &x as *const i32; // creating raw pointer is safe let r2 = &mut x as *mut i32; // creating is safe; dereferencing requires unsafe unsafe { println!("{}", *r1); // SAFETY: r1 points to valid i32 on the stack *r2 = 43; } // 2. Call unsafe functions unsafe fn dangerous() { println!("I am unsafe!"); } unsafe { dangerous(); } // 3. Implement unsafe traits struct MyPtr(*mut u8); unsafe impl Send for MyPtr {} // YOU guarantee this is safe to send across threads unsafe impl Sync for MyPtr {} // 4. Access or modify mutable static variables static mut GLOBAL: i32 = 0; unsafe { GLOBAL += 1; } // data race if called from multiple threads! // 5. Access fields of unions union IntOrFloat { i: i32, f: f32 } let u = IntOrFloat { i: 42 }; unsafe { println!("{}", u.f); } // reinterprets bits — valid bit pattern not guaranteed // Safe abstraction pattern — hide unsafe behind a safe public API pub fn split_at(slice: &[i32], mid: usize) -> (&[i32], &[i32]) { assert!(mid <= slice.len()); let ptr = slice.as_ptr(); unsafe { // SAFETY: mid <= slice.len() guaranteed by assert above. // The two halves don't overlap — safe to create two non-overlapping slices. ( std::slice::from_raw_parts(ptr, mid), std::slice::from_raw_parts(ptr.add(mid), slice.len() - mid), ) } }

// Declare C functions with extern "C" block #[link(name = "c")] // link against libc extern "C" { fn abs(input: i32) -> i32; fn sqrt(x: f64) -> f64; } unsafe { println!("|{1}| = {0}", abs(-5)); println!("sqrt(2) = {}", sqrt(2.0)); } // Structs passed to C — must use #[repr(C)] for C-compatible layout #[repr(C)] struct CPoint { x: f64, y: f64 } extern "C" { fn distance(p1: *const CPoint, p2: *const CPoint) -> f64; } // Exposing Rust functions to C #[no_mangle] // don't mangle the name — C can find it by "add" pub extern "C" fn add(a: i32, b: i32) -> i32 { a + b } // String passing across FFI boundary use std::ffi::{CStr, CString}; use std::os::raw::c_char; extern "C" { fn puts(s: *const c_char); } let s = CString::new("Hello from Rust!").unwrap(); // Rust String → C string unsafe { puts(s.as_ptr()); } // Receive C string extern "C" { fn get_greeting() -> *const c_char; } unsafe { let ptr = get_greeting(); let s = CStr::from_ptr(ptr); // C string → Rust &CStr println!("{}", s.to_str().unwrap()); } // Use bindgen crate to auto-generate FFI bindings from C headers: // bindgen input.h -o bindings.rs

// Default repr: compiler may reorder fields for optimal alignment struct Foo { a: u8, b: u64, c: u8 } // compiler reorders to: b(8), a(1), c(1), padding(6) = 16 bytes // or keeps order: a(1)+7pad, b(8), c(1)+7pad = 24 bytes — depends on version // #[repr(C)] — C-compatible layout, fields in declaration order #[repr(C)] struct CCompatible { a: u8, _pad: [u8; 7], b: u64, c: u8, _pad2: [u8; 7] } // Enum layout: discriminant + largest variant size enum Message { Quit, // 0 bytes payload Move { x: i32, y: i32 },// 8 bytes payload Write(String), // 24 bytes (ptr+len+cap) } // Size: 24 bytes (largest variant) + 8 bytes (discriminant+alignment) = 32 bytes // Null pointer optimization — Option<&T> same size as &T use std::mem::size_of; assert_eq!(size_of::<Option<&i32>>(), size_of::<&i32>()); // true! assert_eq!(size_of::<Option<Box<i32>>>(), size_of::<Box<i32>>()); // true! // None = null pointer; Some(ptr) = non-null — no extra space needed // Zero-sized types (ZST) — no memory, used as markers struct Marker; assert_eq!(size_of::<Marker>(), 0); // 0 bytes — optimized away assert_eq!(size_of::<Vec<Marker>>(), size_of::<usize>() * 3); // just the vec header

// Box<T> — heap allocation, single owner, zero overhead let b = Box::new(5); // 5 lives on heap; b is stack pointer println!("{}", *b); // auto-deref // Use Box for: recursive types, large values to avoid stack copies, // trait objects (Box<dyn Trait>) // Rc<T> — reference counted, single-threaded use std::rc::Rc; let a = Rc::new(String::from("hello")); let b = Rc::clone(&a); // increment ref count — no heap copy println!("{} refs", Rc::strong_count(&a)); // 2 // When last Rc dropped, value freed. Not Send — cannot cross thread boundary. // Arc<T> — atomic reference count, multi-threaded use std::sync::Arc; let a = Arc::new(5); let b = Arc::clone(&a); std::thread::spawn(move || println!("{}", b)); // Arc is Send // Cell<T> — interior mutability for Copy types (no borrowing overhead) use std::cell::Cell; let cell = Cell::new(5); cell.set(10); println!("{}", cell.get()); // 10 // RefCell<T> — interior mutability with runtime borrow checking use std::cell::RefCell; let rc = RefCell::new(vec![1, 2, 3]); rc.borrow().iter().for_each(|x| println!("{}", x)); // immutable borrow rc.borrow_mut().push(4); // mutable borrow // borrow_mut panics at runtime if another borrow is active (same as compile rules, runtime) // Common combination: Rc<RefCell<T>> — shared mutable data, single-threaded let shared = Rc::new(RefCell::new(vec![1, 2])); let clone1 = Rc::clone(&shared); let clone2 = Rc::clone(&shared); clone1.borrow_mut().push(3); println!("{:?}", clone2.borrow()); // [1, 2, 3] // Multi-threaded equivalent: Arc<Mutex<T>> use std::sync::{Arc, Mutex}; let counter = Arc::new(Mutex::new(0)); let c = Arc::clone(&counter); std::thread::spawn(move || { *c.lock().unwrap() += 1; }); // Cow<T> — clone on write: borrowed when possible, owned when needed use std::borrow::Cow; fn process(s: &str) -> Cow<str> { if s.contains(' ') { Cow::Owned(s.replace(' ', "_")) } else { Cow::Borrowed(s) } // no allocation if no spaces }