🦀 Rust Interview Questions

fn main() {
    // Rust reads clearly and compiles to fast native code
    let languages = vec!["Rust", "Go", "C++", "Python"];

    for lang in &languages {
        if lang.starts_with('R') {
            println!("{} is memory-safe without a GC!", lang);
        }
    }
    // Output: Rust is memory-safe without a GC!
}

fn main() {
    // Immutable by default
    let name = "Alice";
    // name = "Bob";  // ❌ ERROR: cannot assign twice to immutable variable

    // Mutable variable
    let mut score = 0;
    score += 10;
    println!("Score: {}", score);  // 10

    // Shadowing — creates a NEW variable (can change type)
    let input = "42";              // &str
    let input = input.parse::<i32>().unwrap();  // now i32
    let input = input * 2;         // still i32, new value
    println!("Result: {}", input); // 84
}

fn main() {
    // Scalar types
    let age: u8 = 28;              // unsigned 8-bit (0..255)
    let temperature: f64 = 36.6;   // 64-bit float
    let is_active: bool = true;
    let emoji: char = '🦀';       // 4-byte Unicode

    // Tuple — fixed size, mixed types
    let user: (&str, u8, bool) = ("Priya", 28, true);
    let (name, age, active) = user;  // destructuring
    println!("{} is {} years old", name, age);

    // Array — fixed size, same type
    let scores: [i32; 5] = [90, 85, 92, 88, 95];
    println!("First score: {}", scores[0]);

    // Array with same value repeated
    let zeros = [0u8; 1024];  // 1024 bytes, all zero
}

// Explicit types for parameters and return
fn calculate_tax(income: f64, rate: f64) -> f64 {
    income * rate / 100.0   // no semicolon = implicit return
}

// Multiple returns via tuple
fn divide(a: f64, b: f64) -> (f64, f64) {
    let quotient = (a / b).floor();
    let remainder = a % b;
    (quotient, remainder)  // returns tuple
}

// Early return with guard clause
fn grade(score: u8) -> &'static str {
    if score >= 90 { return "A"; }
    if score >= 80 { return "B"; }
    if score >= 70 { return "C"; }
    "F"  // final expression — no return keyword needed
}

fn main() {
    let tax = calculate_tax(100_000.0, 30.0);
    println!("Tax: ₹{}", tax);  // Tax: ₹30000

    let (q, r) = divide(17.0, 5.0);
    println!("17 / 5 = {} remainder {}", q, r);  // 3 remainder 2
}

fn main() {
    // Rule 1 & 2: One owner at a time
    let s1 = String::from("hello");
    let s2 = s1;        // ownership MOVES to s2
    // println!("{}", s1);  // ❌ ERROR: s1 is no longer valid

    // Copy types (stack-only) are duplicated, not moved
    let x = 42;
    let y = x;          // x is COPIED (i32 implements Copy)
    println!("x={}, y={}", x, y);  // ✅ both valid

    // Rule 3: Dropped when out of scope
    {
        let temp = String::from("temporary");
        println!("{}", temp);  // ✅ valid here
    }  // ← temp is dropped here, memory freed

    // Ownership transfer to/from functions
    let greeting = create_greeting("Rust");
    consume_string(greeting);
    // println!("{}", greeting);  // ❌ ERROR: moved into function
}

fn create_greeting(name: &str) -> String {
    format!("Hello, {}!", name)  // ownership moves to caller
}

fn consume_string(s: String) {
    println!("Consumed: {}", s);
}  // s is dropped here

fn main() {
    let mut account_balance = 1000.0_f64;

    // Shared (immutable) borrow — multiple readers OK
    print_balance(&account_balance);
    print_balance(&account_balance);  // ✅ multiple & borrows fine

    // Mutable borrow — exclusive access
    apply_interest(&mut account_balance, 5.0);
    println!("After interest: ₹{:.2}", account_balance);

    // ❌ Cannot have & and &mut at the same time
    // let r1 = &account_balance;
    // let r2 = &mut account_balance;  // ERROR: cannot borrow as mutable
    // println!("{}", r1);              // because immutable borrow is still active
}

fn print_balance(balance: &f64) {
    println!("Balance: ₹{:.2}", balance);  // read-only access
}

fn apply_interest(balance: &mut f64, rate: f64) {
    *balance += *balance * rate / 100.0;   // dereference to mutate
}

fn main() {
    // &str — borrowed, immutable, no allocation
    let greeting: &str = "Hello, world!";  // string literal → &'static str

    // String — owned, heap-allocated, growable
    let mut name = String::from("Alice");
    name.push_str(" Smith");  // ✅ can modify
    println!("{}", name);     // Alice Smith

    // Converting between them
    let owned: String = greeting.to_string();   // &str → String (allocates)
    let borrowed: &str = &owned;                // String → &str (free, just a view)

    // Functions should accept &str for flexibility
    greet(&name);       // String auto-derefs to &str
    greet(greeting);    // &str works directly
    greet("Bob");       // literal works too
}

fn greet(name: &str) {
    // Accepts both String (via deref) and &str
    println!("Welcome, {}!", name);
}

#[derive(Debug)]
struct BankAccount {
    holder: String,
    balance: f64,
    is_active: bool,
}

impl BankAccount {
    // Associated function (constructor) — no &self
    fn new(holder: &str, initial_deposit: f64) -> Self {
        Self {
            holder: holder.to_string(),
            balance: initial_deposit,
            is_active: true,
        }
    }

    // Method — borrows self immutably
    fn display(&self) {
        println!("{}: ₹{:.2} ({})", self.holder, self.balance,
            if self.is_active { "active" } else { "closed" });
    }

    // Method — borrows self mutably
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }

    // Method — consumes self (takes ownership)
    fn close(self) -> f64 {
        println!("Closing account for {}", self.holder);
        self.balance  // return final balance
    }
}

fn main() {
    let mut acc = BankAccount::new("Priya", 5000.0);
    acc.deposit(1500.0);
    acc.display();  // Priya: ₹6500.00 (active)

    let final_balance = acc.close();
    // acc.display();  // ❌ ERROR: acc was consumed by close()
}

// Enum with data in variants
enum PaymentMethod {
    Cash,
    Card { last_four: String, network: String },
    UPI(String),  // tuple variant
    Wallet { provider: String, balance: f64 },
}

fn process_payment(method: &PaymentMethod, amount: f64) {
    match method {
        PaymentMethod::Cash => {
            println!("Cash payment of ₹{:.2}", amount);
        }
        PaymentMethod::Card { last_four, network } => {
            println!("Charging ₹{:.2} to {} card ending {}", amount, network, last_four);
        }
        PaymentMethod::UPI(vpa) => {
            println!("UPI request sent to {} for ₹{:.2}", vpa, amount);
        }
        PaymentMethod::Wallet { provider, balance } if *balance >= amount => {
            println!("Paying ₹{:.2} from {} wallet", amount, provider);
        }
        PaymentMethod::Wallet { provider, .. } => {
            println!("Insufficient {} wallet balance!", provider);
        }
    }
}

fn main() {
    let card = PaymentMethod::Card {
        last_four: "4242".into(),
        network: "Visa".into(),
    };
    process_payment(&card, 999.0);
    // Output: Charging ₹999.00 to Visa card ending 4242
}

use std::fs;
use std::io;
use std::num::ParseIntError;

// Option — value that might not exist
fn find_user(id: u32) -> Option<String> {
    match id {
        1 => Some("Alice".to_string()),
        2 => Some("Bob".to_string()),
        _ => None,
    }
}

// Result with ? operator for clean error propagation
fn read_age_from_file(path: &str) -> Result<u8, Box<dyn std::error::Error>> {
    let contents = fs::read_to_string(path)?;  // ? returns early if Err
    let age = contents.trim().parse::<u8>()?;   // ? propagates parse error
    Ok(age)
}

fn main() {
    // Option handling
    match find_user(1) {
        Some(name) => println!("Found: {}", name),
        None       => println!("User not found"),
    }

    // Concise Option methods
    let name = find_user(99).unwrap_or("Guest".to_string());
    println!("Welcome, {}", name);  // Welcome, Guest

    // Result handling
    match read_age_from_file("age.txt") {
        Ok(age)  => println!("Age: {}", age),
        Err(e)   => println!("Error: {}", e),
    }
}

use std::fmt;

// Define a trait with a required method and a default method
trait Describable {
    fn describe(&self) -> String;

    // Default implementation — types can override or keep it
    fn summary(&self) -> String {
        format!("Summary: {}", self.describe())
    }
}

struct Product { name: String, price: f64 }
struct Service { name: String, hourly_rate: f64 }

impl Describable for Product {
    fn describe(&self) -> String {
        format!("{} — ₹{:.2}", self.name, self.price)
    }
}

impl Describable for Service {
    fn describe(&self) -> String {
        format!("{} — ₹{:.2}/hr", self.name, self.hourly_rate)
    }
}

// Static dispatch — compiler generates separate code per type
fn print_item(item: &impl Describable) {
    println!("{}", item.summary());
}

fn main() {
    let laptop = Product { name: "Laptop".into(), price: 75000.0 };
    let consulting = Service { name: "DevOps Consulting".into(), hourly_rate: 5000.0 };

    print_item(&laptop);      // Summary: Laptop — ₹75000.00
    print_item(&consulting);  // Summary: DevOps Consulting — ₹5000.00/hr
}

use std::fmt::Display;

// Generic function with trait bound
fn largest<T: PartialOrd + Display>(list: &[T]) -> &T {
    let mut max = &list[0];
    for item in &list[1..] {
        if item > max {
            max = item;
        }
    }
    max
}

// Generic struct
struct Cache<K, V> {
    entries: Vec<(K, V)>,
    max_size: usize,
}

// impl with where clause for complex bounds
impl<K, V> Cache<K, V>
where
    K: Eq + Display + Clone,
    V: Clone,
{
    fn new(max_size: usize) -> Self {
        Self { entries: Vec::new(), max_size }
    }

    fn get(&self, key: &K) -> Option<&V> {
        self.entries.iter()
            .find(|(k, _)| k == key)
            .map(|(_, v)| v)
    }

    fn insert(&mut self, key: K, value: V) {
        if self.entries.len() >= self.max_size {
            self.entries.remove(0);  // evict oldest
        }
        self.entries.push((key, value));
    }
}

fn main() {
    let numbers = vec![34, 50, 25, 100, 65];
    println!("Largest: {}", largest(&numbers));  // 100

    let mut cache = Cache::new(3);
    cache.insert("user:1", "Alice");
    cache.insert("user:2", "Bob");
    println!("Found: {:?}", cache.get(&"user:1"));  // Some("Alice")
}

// The compiler can't tell which input's lifetime the output shares
// We annotate: the returned reference lives as long as BOTH inputs
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() >= y.len() { x } else { y }
}

// Struct holding a reference must declare the lifetime
struct Excerpt<'a> {
    text: &'a str,
    page: u32,
}

impl<'a> Excerpt<'a> {
    fn highlight(&self) -> &str {
        // Lifetime elision: compiler infers output lifetime = &self
        &self.text[..20.min(self.text.len())]
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let result;
    {
        let first_sentence = &novel[..16];  // "Call me Ishmael."
        result = longest(first_sentence, "Hello world");
    }
    println!("Longest: {}", result);  // ✅ OK — "Call me Ishmael." outlives this scope

    let excerpt = Excerpt { text: &novel, page: 1 };
    println!("Preview: {}", excerpt.highlight());
}

fn main() {
    // Fn — read-only capture
    let multiplier = 3;
    let triple = |x: i32| x * multiplier;  // captures &multiplier
    println!("{}, {}", triple(5), triple(10));  // 15, 30 (callable multiple times)

    // FnMut — mutable capture
    let mut total = 0;
    let mut accumulate = |x: i32| {
        total += x;  // captures &mut total
    };
    accumulate(10);
    accumulate(20);
    println!("Total: {}", total);  // 30

    // FnOnce — moves captured value
    let name = String::from("Alice");
    let greet = move || {
        println!("Hello, {}!", name);  // takes ownership of name
        // name is moved into the closure
    };
    greet();
    // greet();  // ✅ works if closure implements Fn (this one does)
    // println!("{}", name);  // ❌ ERROR: name was moved into closure

    // Closures as function parameters
    let numbers = vec![1, 2, 3, 4, 5];
    let evens: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
    println!("Evens: {:?}", evens);  // [2, 4]
}

// Accepting closures as parameters with trait bounds
fn apply_twice<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(f(x))
}

fn main() {
    let transactions = vec![1200.0, -500.0, 3400.0, -150.0, 800.0, -2000.0];

    // Chain of lazy combinators → consuming adaptor
    let total_deposits: f64 = transactions.iter()
        .filter(|&&t| t > 0.0)          // keep positives
        .map(|t| t * 0.98)              // apply 2% fee
        .sum();                          // consume & add up

    println!("Net deposits after fees: ₹{:.2}", total_deposits);
    // ₹5292.00

    // enumerate + filter_map for index + transform
    let large_txns: Vec<String> = transactions.iter()
        .enumerate()
        .filter_map(|(i, &amount)| {
            if amount.abs() > 1000.0 {
                Some(format!("#{}: ₹{:.2}", i + 1, amount))
            } else {
                None
            }
        })
        .collect();

    println!("Large transactions: {:?}", large_txns);
    // ["#1: ₹1200.00", "#3: ₹3400.00", "#6: ₹-2000.00"]

    // Custom iterator
    let fibs: Vec<u64> = Fibonacci::new().take(10).collect();
    println!("Fibonacci: {:?}", fibs);
}

struct Fibonacci { a: u64, b: u64 }

impl Fibonacci {
    fn new() -> Self { Self { a: 0, b: 1 } }
}

impl Iterator for Fibonacci {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let next = self.a;
        self.a = self.b;
        self.b = next + self.b;
        Some(next)
    }
}

use std::collections::{HashMap, HashSet};

fn main() {
    // Vec — growable array
    let mut prices: Vec<f64> = Vec::new();
    prices.push(99.99);
    prices.push(149.50);
    prices.push(29.99);
    prices.sort_by(|a, b| a.partial_cmp(b).unwrap());
    println!("Sorted: {:?}", prices);  // [29.99, 99.99, 149.5]

    // HashMap — key-value store
    let mut inventory: HashMap<&str, u32> = HashMap::new();
    inventory.insert("Laptop", 50);
    inventory.insert("Mouse", 200);
    inventory.insert("Laptop", 48);  // overwrites

    // Entry API — insert or modify
    inventory.entry("Keyboard").or_insert(100);
    *inventory.entry("Mouse").or_insert(0) += 10;  // 200 + 10 = 210

    for (item, count) in &inventory {
        println!("{}: {} units", item, count);
    }

    // HashSet — unique values + set operations
    let backend: HashSet<&str> = ["Rust", "Go", "Python"].iter().copied().collect();
    let frontend: HashSet<&str> = ["JavaScript", "Rust", "TypeScript"].iter().copied().collect();

    let fullstack: HashSet<_> = backend.intersection(&frontend).collect();
    println!("Fullstack languages: {:?}", fullstack);  // {"Rust"}
}

// src/lib.rs
pub mod models {
    // pub struct is public, but fields can be private
    pub struct User {
        pub name: String,
        pub email: String,
        password_hash: String,  // private — not accessible outside
    }

    impl User {
        pub fn new(name: &str, email: &str, password: &str) -> Self {
            Self {
                name: name.to_string(),
                email: email.to_string(),
                password_hash: hash(password),
            }
        }
    }

    fn hash(input: &str) -> String {
        format!("hashed_{}", input)  // simplified
    }
}

pub mod services {
    use super::models::User;  // import from sibling module

    pub fn register(name: &str, email: &str, password: &str) -> User {
        let user = User::new(name, email, password);
        println!("Registered: {}", user.name);
        user
    }
}

// Re-export for convenient access
pub use models::User;
pub use services::register;

# Cargo.toml
[package]
name = "my-api"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.12", features = ["json"] }

[dev-dependencies]
criterion = "0.5"       # benchmarks only

[profile.release]
opt-level = 3           # max optimization
lto = true              # link-time optimization
strip = true            # strip debug symbols

# ── Common Cargo commands ──
# cargo new my-project       # create new project
# cargo build                # debug build
# cargo build --release      # optimized build
# cargo run                  # build + run
# cargo test                 # run all tests
# cargo doc --open           # generate + open docs
# cargo clippy               # lint for idioms
# cargo fmt                  # format code
# cargo add serde            # add dependency (cargo-edit)
# cargo update               # update Cargo.lock

use std::rc::Rc;
use std::sync::Arc;
use std::thread;

fn main() {
    // Box — heap allocation, single owner
    // Required for recursive types
    #[derive(Debug)]
    enum List {
        Cons(i32, Box<List>),
        Nil,
    }
    let list = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));
    println!("{:?}", list);

    // Rc — shared ownership, single-threaded
    let config = Rc::new(String::from("production"));
    let service_a = Rc::clone(&config);  // count: 2
    let service_b = Rc::clone(&config);  // count: 3
    println!("Refs: {}", Rc::strong_count(&config));  // 3
    println!("A uses: {}, B uses: {}", service_a, service_b);

    // Arc — shared ownership, multi-threaded
    let shared_data = Arc::new(vec![1, 2, 3, 4, 5]);
    let mut handles = vec![];

    for i in 0..3 {
        let data = Arc::clone(&shared_data);  // cheap atomic increment
        handles.push(thread::spawn(move || {
            let sum: i32 = data.iter().sum();
            println!("Thread {}: sum = {}", i, sum);
        }));
    }

    for h in handles { h.join().unwrap(); }
}

use std::cell::RefCell;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // RefCell — runtime borrow checking (single-threaded)
    let data = RefCell::new(vec![1, 2, 3]);
    data.borrow_mut().push(4);  // mutable borrow at runtime
    println!("Data: {:?}", data.borrow());  // [1, 2, 3, 4]

    // Rc<RefCell<T>> — shared + mutable (single-threaded)
    let shared_log = Rc::new(RefCell::new(Vec::<String>::new()));

    let logger1 = Rc::clone(&shared_log);
    let logger2 = Rc::clone(&shared_log);

    logger1.borrow_mut().push("Request received".into());
    logger2.borrow_mut().push("Response sent".into());
    println!("Logs: {:?}", shared_log.borrow());

    // Arc<Mutex<T>> — shared + mutable (multi-threaded)
    let counter = Arc::new(Mutex::new(0u64));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        }));
    }
    for h in handles { h.join().unwrap(); }
    println!("Counter: {}", *counter.lock().unwrap());  // 10
}

// Safe abstraction over unsafe code
fn split_at_mut(slice: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = slice.len();
    assert!(mid <= len);

    let ptr = slice.as_mut_ptr();
    // SAFETY: We have exclusive access to `slice`.
    // The two sub-slices don't overlap because mid splits them.
    unsafe {
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

// FFI — calling C functions
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    let mut data = vec![1, 2, 3, 4, 5];
    let (left, right) = split_at_mut(&mut data, 3);
    left[0] = 99;
    println!("Left: {:?}, Right: {:?}", left, right);
    // Left: [99, 2, 3], Right: [4, 5]

    // Calling C function
    let result = unsafe { abs(-42) };
    println!("abs(-42) = {}", result);  // 42
}

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> &str;
}

struct Circle { radius: f64 }
struct Rectangle { width: f64, height: f64 }

impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius * self.radius }
    fn name(&self) -> &str { "Circle" }
}

impl Shape for Rectangle {
    fn area(&self) -> f64 { self.width * self.height }
    fn name(&self) -> &str { "Rectangle" }
}

// Static dispatch — monomorphized, zero cost, larger binary
fn print_area_static(shape: &impl Shape) {
    println!("{}: {:.2}", shape.name(), shape.area());
}

// Dynamic dispatch — vtable, one function copy, runtime cost
fn print_area_dynamic(shape: &dyn Shape) {
    println!("{}: {:.2}", shape.name(), shape.area());
}

// Dynamic dispatch needed: heterogeneous collection
fn total_area(shapes: &[Box<dyn Shape>]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}

fn main() {
    let c = Circle { radius: 5.0 };
    let r = Rectangle { width: 4.0, height: 6.0 };

    print_area_static(&c);  // monomorphized for Circle
    print_area_static(&r);  // separate copy for Rectangle

    // Heterogeneous collection — must use dyn
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 3.0 }),
        Box::new(Rectangle { width: 10.0, height: 5.0 }),
    ];
    println!("Total area: {:.2}", total_area(&shapes));
}

// Associated type — ONE Item type per iterator
trait Processor {
    type Input;
    type Output;
    type Error;

    fn process(&self, input: Self::Input) -> Result<Self::Output, Self::Error>;
}

struct CsvParser;

impl Processor for CsvParser {
    type Input = String;                  // set once
    type Output = Vec<Vec<String>>;
    type Error = std::io::Error;

    fn process(&self, input: String) -> Result<Vec<Vec<String>>, std::io::Error> {
        let rows = input.lines()
            .map(|line| line.split(',').map(String::from).collect())
            .collect();
        Ok(rows)
    }
}

// Generic parameter — MULTIPLE implementations for same type
trait Convertible<T> {
    fn convert(&self) -> T;
}

struct Temperature(f64);

impl Convertible<f64> for Temperature {
    fn convert(&self) -> f64 { self.0 * 9.0 / 5.0 + 32.0 }  // to Fahrenheit
}

impl Convertible<String> for Temperature {
    fn convert(&self) -> String { format!("{:.1}°C", self.0) }  // to string
}

fn main() {
    let parser = CsvParser;
    let csv = "name,age\nAlice,30\nBob,25".to_string();
    let rows = parser.process(csv).unwrap();
    println!("{:?}", rows);

    let temp = Temperature(100.0);
    let fahrenheit: f64 = temp.convert();
    let label: String = temp.convert();
    println!("{}°F = {}", fahrenheit, label);  // 212°F = 100.0°C
}

use std::pin::Pin;
use std::future::Future;
use std::task::{Context, Poll};

// Most types are Unpin — Pin has no effect
fn demonstrate_unpin() {
    let mut x = Box::pin(42);  // i32 is Unpin
    *x.as_mut() = 100;        // ✅ can still modify
    println!("Pinned i32: {}", x);
}

// Why Pin matters: async futures are self-referential
async fn fetch_and_process(url: &str) -> String {
    let data = reqwest::get(url).await;  // ← .await suspends here
    // After suspend, `data` is a field in the future's state machine
    // If the future moved, internal references to `data` would dangle
    format!("Processed: {}", url)
}

// Custom future must use Pin<&mut Self>
struct Delay {
    duration: std::time::Duration,
    started: bool,
}

impl Future for Delay {
    type Output = ();

    // Pin<&mut Self> — guarantees self won't move between polls
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        if !self.started {
            // Start timer, register waker
            cx.waker().wake_by_ref();
            Poll::Pending
        } else {
            Poll::Ready(())
        }
    }
}

fn main() {
    demonstrate_unpin();

    // Pin a future to the heap
    let future = Box::pin(fetch_and_process("https://api.example.com"));
    // `future` cannot be moved now — internal references are safe
}

use tokio::time::{sleep, Duration};
use tokio::join;

async fn fetch_user(id: u32) -> String {
    sleep(Duration::from_millis(100)).await;  // simulate I/O
    format!("User#{}", id)
}

async fn fetch_orders(user_id: u32) -> Vec<String> {
    sleep(Duration::from_millis(150)).await;
    vec![format!("Order#{}01", user_id), format!("Order#{}02", user_id)]
}

// Sequential — 250ms total
async fn sequential() {
    let user = fetch_user(1).await;
    let orders = fetch_orders(1).await;
    println!("{}: {:?}", user, orders);
}

// Concurrent — 150ms total (max of both)
async fn concurrent() {
    let (user, orders) = join!(fetch_user(1), fetch_orders(1));
    println!("{}: {:?}", user, orders);
}

#[tokio::main]
async fn main() {
    // Both produce the same result, but concurrent is faster
    sequential().await;
    concurrent().await;

    // Spawning independent tasks
    let handle = tokio::spawn(async {
        fetch_user(42).await
    });
    let result = handle.await.unwrap();
    println!("Spawned: {}", result);
}

use std::sync::{Arc, Mutex};
use std::thread;

// ✅ Send — can move to another thread
fn send_example() {
    let data = vec![1, 2, 3];  // Vec<i32> is Send
    let handle = thread::spawn(move || {
        println!("From thread: {:?}", data);  // data moved here
    });
    handle.join().unwrap();
}

// ✅ Sync — can share references across threads
fn sync_example() {
    let data = Arc::new(vec![1, 2, 3]);  // Arc<Vec<i32>> is Send + Sync
    let mut handles = vec![];

    for i in 0..3 {
        let data = Arc::clone(&data);
        handles.push(thread::spawn(move || {
            println!("Thread {}: {:?}", i, data);  // shared read
        }));
    }
    for h in handles { h.join().unwrap(); }
}

// ❌ Rc is NOT Send — compiler prevents this
// use std::rc::Rc;
// fn rc_across_threads() {
//     let data = Rc::new(42);
//     thread::spawn(move || {
//         println!("{}", data);  // ERROR: Rc<i32> cannot be sent between threads
//     });
// }

// Arc<Mutex<T>> = Send + Sync (thread-safe shared mutation)
fn shared_mutation() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            *counter.lock().unwrap() += 1;
        }));
    }
    for h in handles { h.join().unwrap(); }
    println!("Counter: {}", *counter.lock().unwrap());  // 10
}

fn main() {
    send_example();
    sync_example();
    shared_mutation();
}

// Declarative macro — variadic HashMap creation
macro_rules! map {
    ($($key:expr => $val:expr),* $(,)?) => {{
        let mut m = std::collections::HashMap::new();
        $(m.insert($key, $val);)*
        m
    }};
}

// Macro for concise error context
macro_rules! ensure {
    ($cond:expr, $msg:expr) => {
        if !($cond) {
            return Err(format!("Assertion failed: {}", $msg).into());
        }
    };
}

fn process_order(qty: i32, price: f64) -> Result<f64, Box<dyn std::error::Error>> {
    ensure!(qty > 0, "quantity must be positive");
    ensure!(price > 0.0, "price must be positive");
    Ok(qty as f64 * price)
}

fn main() {
    // HashMap in one line
    let config = map! {
        "host" => "localhost",
        "port" => "8080",
        "env"  => "production",
    };
    println!("Config: {:?}", config);

    // vec! and println! are also macros
    let items = vec![1, 2, 3];  // vec! = macro (variadic)
    println!("{:?}", items);     // println! = macro (format string)

    match process_order(5, 99.99) {
        Ok(total) => println!("Total: ₹{:.2}", total),
        Err(e) => println!("Error: {}", e),
    }
}

// This high-level iterator chain...
fn sum_of_squares_idiomatic(data: &[i64]) -> i64 {
    data.iter()
        .filter(|&&x| x > 0)
        .map(|&x| x * x)
        .sum()
}

// ...compiles to the SAME assembly as this hand-written loop
fn sum_of_squares_manual(data: &[i64]) -> i64 {
    let mut total: i64 = 0;
    for i in 0..data.len() {
        if data[i] > 0 {
            total += data[i] * data[i];
        }
    }
    total
}

// Verify with: cargo rustc --release -- --emit=asm
// Both produce identical x86 assembly with -O2

// Generic function — monomorphized, no runtime dispatch
fn max_value<T: PartialOrd>(a: T, b: T) -> T {
    if a >= b { a } else { b }
}

fn main() {
    let data = vec![3, -1, 4, -1, 5, 9, -2, 6];

    let r1 = sum_of_squares_idiomatic(&data);
    let r2 = sum_of_squares_manual(&data);
    assert_eq!(r1, r2);  // same result
    println!("Sum of positive squares: {}", r1);  // 167

    // Monomorphized — max_value::<i32> and max_value::<f64> are separate functions
    println!("{}", max_value(10, 20));       // i32 version
    println!("{}", max_value(3.14, 2.71));   // f64 version
}

// Newtype pattern for type safety
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct UserId(u64);

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct OrderId(u64);

// Cannot accidentally pass OrderId where UserId is expected
pub fn get_user(id: UserId) -> String {
    format!("User#{}", id.0)
}

// Builder pattern for complex construction
#[derive(Debug)]
pub struct ServerConfig {
    host: String,
    port: u16,
    max_connections: usize,
    tls: bool,
}

pub struct ServerConfigBuilder {
    host: String,
    port: u16,
    max_connections: usize,
    tls: bool,
}

impl ServerConfigBuilder {
    pub fn new(host: impl Into<String>) -> Self {
        Self {
            host: host.into(),
            port: 8080,
            max_connections: 1000,
            tls: false,
        }
    }

    pub fn port(mut self, port: u16) -> Self { self.port = port; self }
    pub fn max_connections(mut self, n: usize) -> Self { self.max_connections = n; self }
    pub fn tls(mut self, enabled: bool) -> Self { self.tls = enabled; self }

    pub fn build(self) -> ServerConfig {
        ServerConfig {
            host: self.host,
            port: self.port,
            max_connections: self.max_connections,
            tls: self.tls,
        }
    }
}

fn main() {
    let config = ServerConfigBuilder::new("0.0.0.0")
        .port(443)
        .tls(true)
        .max_connections(10_000)
        .build();
    println!("{:?}", config);

    let user = get_user(UserId(42));
    // get_user(OrderId(42));  // ❌ ERROR: expected UserId, found OrderId
}

// ── Library layer: precise error types with thiserror ──
use thiserror::Error;

#[derive(Error, Debug)]
pub enum DatabaseError {
    #[error("connection failed: {0}")]
    Connection(String),

    #[error("query failed: {query}")]
    Query { query: String, #[source] source: std::io::Error },

    #[error("record not found: {0}")]
    NotFound(String),

    #[error(transparent)]
    Other(#[from] std::io::Error),
}

pub fn find_user(id: u64) -> Result<String, DatabaseError> {
    if id == 0 {
        return Err(DatabaseError::NotFound(format!("user:{}", id)));
    }
    Ok(format!("User#{}", id))
}

// ── Application layer: context with anyhow ──
use anyhow::{Context, Result};

fn process_order(user_id: u64, product: &str) -> Result<String> {
    let user = find_user(user_id)
        .context(format!("fetching user {} for order", user_id))?;

    let receipt = format!("{} purchased {}", user, product);
    Ok(receipt)
}

fn main() {
    match process_order(0, "Laptop") {
        Ok(receipt) => println!("{}", receipt),
        Err(e) => {
            // Full error chain with context
            eprintln!("Error: {:#}", e);
            // Error: fetching user 0 for order: record not found: user:0
        }
    }
}

# Root Cargo.toml (workspace definition)
[workspace]
members = [
    "api-server",       # binary crate
    "worker",           # binary crate
    "common-types",     # library crate (shared)
    "auth-middleware",   # library crate (shared)
]

# Centralized dependency versions (Rust 1.64+)
[workspace.dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.8", features = ["postgres", "runtime-tokio"] }

# ── api-server/Cargo.toml ──
[package]
name = "api-server"
version = "0.1.0"
edition = "2021"

[dependencies]
common-types = { path = "../common-types" }
auth-middleware = { path = "../auth-middleware" }
serde.workspace = true       # uses workspace version
tokio.workspace = true

# ── common-types/src/lib.rs ──
# Shared types used by api-server and worker
# pub struct UserId(pub u64);
# pub struct OrderEvent { ... }

// ── Calling C from Rust ──
// Link to system libm
#[link(name = "m")]
extern "C" {
    fn sqrt(x: f64) -> f64;
    fn pow(base: f64, exp: f64) -> f64;
}

// C-compatible struct layout
#[repr(C)]
#[derive(Debug)]
struct Point {
    x: f64,
    y: f64,
}

// ── Exposing Rust to C ──
#[no_mangle]
pub extern "C" fn rust_distance(p1: &Point, p2: &Point) -> f64 {
    let dx = p2.x - p1.x;
    let dy = p2.y - p1.y;
    // SAFETY: sqrt from libm is well-defined for non-negative inputs
    unsafe { sqrt(dx * dx + dy * dy) }
}

// Safe wrapper over unsafe FFI
pub fn safe_sqrt(x: f64) -> Option<f64> {
    if x < 0.0 {
        None
    } else {
        // SAFETY: sqrt is defined for non-negative floats
        Some(unsafe { sqrt(x) })
    }
}

fn main() {
    let result = safe_sqrt(144.0);
    println!("sqrt(144) = {:?}", result);  // Some(12.0)

    let p1 = Point { x: 0.0, y: 0.0 };
    let p2 = Point { x: 3.0, y: 4.0 };
    let dist = rust_distance(&p1, &p2);
    println!("Distance: {}", dist);  // 5.0
}

#![no_std]
#![no_main]

use core::panic::PanicInfo;

// Bare-metal panic handler — required with no_std
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}  // halt on panic
}

// Entry point for ARM Cortex-M microcontroller
#[no_mangle]
pub extern "C" fn _start() -> ! {
    // Memory-mapped I/O: toggle an LED on GPIO pin
    const GPIO_BASE: usize = 0x4000_0000;
    const GPIO_SET: *mut u32 = (GPIO_BASE + 0x08) as *mut u32;
    const LED_PIN: u32 = 1 << 13;

    loop {
        // SAFETY: GPIO_SET is a valid hardware register address
        unsafe {
            core::ptr::write_volatile(GPIO_SET, LED_PIN);
        }
        // Simple delay
        for _ in 0..1_000_000 {
            core::hint::spin_loop();
        }
    }
}

// ── Using core without std ──
// All these work without std:
fn process_data(data: &[u8]) -> Option<u8> {
    let sum: u16 = data.iter().map(|&x| x as u16).sum();
    if data.is_empty() { None } else { Some((sum / data.len() as u16) as u8) }
}

// src/lib.rs
pub fn validate_email(email: &str) -> bool {
    let parts: Vec<&str> = email.split('@').collect();
    parts.len() == 2 && !parts[0].is_empty() && parts[1].contains('.')
}

/// Calculates compound interest
/// ```
/// let result = mylib::compound_interest(1000.0, 0.1, 5);
/// assert!((result - 1610.51).abs() < 0.01);
/// ```
pub fn compound_interest(principal: f64, rate: f64, years: u32) -> f64 {
    principal * (1.0 + rate).powi(years as i32)
}

// ── Unit tests (same file) ──
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn valid_email() {
        assert!(validate_email("user@example.com"));
    }

    #[test]
    fn invalid_email_no_at() {
        assert!(!validate_email("userexample.com"));
    }

    #[test]
    #[should_panic(expected = "overflow")]
    fn test_overflow() {
        let _: u8 = 255u8 + 1;  // panics in debug mode
    }
}

// ── tests/integration_test.rs (integration test) ──
// use mylib::validate_email;
// #[test]
// fn test_from_external() {
//     assert!(validate_email("test@test.com"));
// }

// ── Property-based testing with proptest ──
// use proptest::prelude::*;
// proptest! {
//     #[test]
//     fn email_with_at_and_dot_is_valid(
//         user in "[a-z]{1,10}",
//         domain in "[a-z]{1,5}\.[a-z]{2,3}"
//     ) {
//         let email = format!("{}@{}", user, domain);
//         assert!(validate_email(&email));
//     }
// }

// ── Typestate pattern: compile-time state machine ──
// States are types — you cannot call methods on the wrong state
struct Draft;
struct Review;
struct Published;

struct Article<State> {
    title: String,
    content: String,
    _state: std::marker::PhantomData<State>,
}

impl Article<Draft> {
    fn new(title: &str) -> Self {
        Self { title: title.into(), content: String::new(), _state: std::marker::PhantomData }
    }

    fn write(&mut self, text: &str) {
        self.content.push_str(text);
    }

    // Transition: Draft → Review (consumes Draft, returns Review)
    fn submit_for_review(self) -> Article<Review> {
        Article { title: self.title, content: self.content, _state: std::marker::PhantomData }
    }
}

impl Article<Review> {
    fn approve(self) -> Article<Published> {
        Article { title: self.title, content: self.content, _state: std::marker::PhantomData }
    }

    fn reject(self) -> Article<Draft> {
        Article { title: self.title, content: self.content, _state: std::marker::PhantomData }
    }
}

impl Article<Published> {
    fn read(&self) -> &str {
        &self.content
    }
}

fn main() {
    let mut article = Article::<Draft>::new("Rust Patterns");
    article.write("Typestate makes invalid states unrepresentable.");

    // article.read();  // ❌ ERROR: no method `read` on Article<Draft>

    let article = article.submit_for_review();
    // article.write("more");  // ❌ ERROR: no method `write` on Article<Review>

    let article = article.approve();
    println!("{}", article.read());  // ✅ only Published articles can be read
}

// Cargo.toml
// [dev-dependencies]
// criterion = { version = "0.5", features = ["html_reports"] }
//
// [[bench]]
// name = "sorting"
// harness = false

// benches/sorting.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        n => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn fibonacci_iterative(n: u64) -> u64 {
    let (mut a, mut b) = (0u64, 1u64);
    for _ in 0..n {
        let temp = b;
        b = a + b;
        a = temp;
    }
    a
}

fn bench_fibonacci(c: &mut Criterion) {
    let mut group = c.benchmark_group("fibonacci");

    group.bench_function("recursive_20", |b| {
        b.iter(|| fibonacci(black_box(20)))
    });

    group.bench_function("iterative_20", |b| {
        b.iter(|| fibonacci_iterative(black_box(20)))
    });

    group.finish();
}

criterion_group!(benches, bench_fibonacci);
criterion_main!(benches);

// Run: cargo bench
// Output:
// fibonacci/recursive_20  time: [25.431 µs 25.578 µs 25.733 µs]
// fibonacci/iterative_20  time: [3.1234 ns 3.1456 ns 3.1687 ns]  ← 8000x faster

# Cargo.toml — enable debug symbols in release for profiling
[profile.release]
debug = true          # debug info for profiling
# opt-level = 3      # still fully optimized

# ── Flamegraph (Linux/macOS) ──
# Install: cargo install flamegraph
# Run:     cargo flamegraph --bin my-app
# Opens:   flamegraph.svg in browser

# ── perf (Linux) ──
# cargo build --release
# perf record -g ./target/release/my-app
# perf report
# perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

# ── DHAT for heap profiling ──
# In code:
use std::collections::HashMap;

fn demonstrate_allocation_patterns() {
    // Pattern 1: Many small allocations (DHAT will flag this)
    let mut strings: Vec<String> = Vec::new();
    for i in 0..10_000 {
        strings.push(format!("item_{}", i));  // 10K heap allocations
    }

    // Pattern 2: Pre-allocated (DHAT shows fewer allocs)
    let mut map: HashMap<u32, String> = HashMap::with_capacity(10_000);
    for i in 0..10_000 {
        map.insert(i, format!("item_{}", i));
    }

    // Pattern 3: Reuse allocation
    let mut buffer = String::with_capacity(1024);
    for i in 0..10_000 {
        buffer.clear();  // reuses allocation
        buffer.push_str(&format!("item_{}", i));
    }
}

fn main() {
    demonstrate_allocation_patterns();
}

use rayon::prelude::*;
use std::time::Instant;

fn is_prime(n: u64) -> bool {
    if n < 2 { return false; }
    if n < 4 { return true; }
    if n % 2 == 0 || n % 3 == 0 { return false; }
    let mut i = 5;
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 { return false; }
        i += 6;
    }
    true
}

fn main() {
    let numbers: Vec<u64> = (2..1_000_000).collect();

    // Sequential
    let start = Instant::now();
    let seq_count = numbers.iter().filter(|&&n| is_prime(n)).count();
    let seq_time = start.elapsed();

    // Parallel — just change .iter() to .par_iter()
    let start = Instant::now();
    let par_count = numbers.par_iter().filter(|&&n| is_prime(n)).count();
    let par_time = start.elapsed();

    println!("Sequential: {} primes in {:?}", seq_count, seq_time);
    println!("Parallel:   {} primes in {:?}", par_count, par_time);
    // Sequential: 78498 primes in 142ms
    // Parallel:   78498 primes in 28ms  (5x faster on 8 cores)

    // Parallel sort
    let mut data: Vec<i32> = (0..10_000_000).rev().collect();
    data.par_sort_unstable();  // parallel sort — 3-4x faster

    // Parallel map-reduce
    let total: f64 = numbers.par_iter()
        .map(|&n| (n as f64).sqrt())
        .sum();
    println!("Sum of square roots: {:.2}", total);
}

use tokio::time::{sleep, Duration};
use std::sync::Arc;

// Configure runtime explicitly
#[tokio::main(flavor = "multi_thread", worker_threads = 4)]
async fn main() {
    // ✅ I/O-bound work — runs on async runtime
    let api_result = fetch_data("https://api.example.com").await;

    // ✅ CPU-bound work — offload to blocking pool
    let hash = tokio::task::spawn_blocking(move || {
        // Heavy computation — would block the async runtime
        expensive_hash("password123")
    }).await.unwrap();

    println!("Hash: {}", hash);

    // ✅ Concurrent I/O with bounded concurrency
    let urls = vec!["url1", "url2", "url3", "url4", "url5"];
    let semaphore = Arc::new(tokio::sync::Semaphore::new(3));  // max 3 concurrent

    let mut handles = vec![];
    for url in urls {
        let sem = Arc::clone(&semaphore);
        handles.push(tokio::spawn(async move {
            let _permit = sem.acquire().await.unwrap();
            fetch_data(url).await
        }));
    }

    for h in handles {
        let result = h.await.unwrap();
        println!("{}", result);
    }
}

async fn fetch_data(url: &str) -> String {
    sleep(Duration::from_millis(100)).await;  // simulate I/O
    format!("Response from {}", url)
}

fn expensive_hash(input: &str) -> String {
    // Simulate CPU-heavy work
    let mut result = input.to_string();
    for _ in 0..1000 {
        result = format!("{:x}", md5_hash(&result));
    }
    result
}

fn md5_hash(input: &str) -> u64 {
    input.bytes().fold(0u64, |acc, b| acc.wrapping_mul(31).wrapping_add(b as u64))
}

# Cargo.toml — Maximum performance
[profile.release]
opt-level = 3          # max speed optimization
lto = "fat"            # full link-time optimization
codegen-units = 1      # single codegen unit = better optimization
strip = true           # strip symbols
panic = "abort"        # no unwinding overhead

# Cargo.toml — Minimum binary size
[profile.release-small]
inherits = "release"
opt-level = "z"        # optimize for size
lto = true
codegen-units = 1
strip = true
panic = "abort"

# ── Faster compilation ──
# .cargo/config.toml
[build]
# Use mold linker (10x faster linking on Linux)
# rustflags = ["-C", "link-arg=-fuse-ld=mold"]

# Use cranelift backend for dev builds (2-3x faster compile, slower runtime)
# [unstable]
# codegen-backend = "cranelift"

# ── Analyze binary size ──
# cargo install cargo-bloat
# cargo bloat --release -n 20       # top 20 largest functions
# cargo bloat --release --crates    # size per dependency

# ── Typical results ──
# Default release:      ~8.5 MB
# With strip + LTO:     ~2.1 MB
# With opt-level="z":   ~1.4 MB
# With panic="abort":   ~1.2 MB
# UPX compressed:       ~450 KB