Rust Borrowing Quick Reference Cheat Sheet

// Immutable references (multiple OK)
let s = String::from("hello");
let r1 = &s;
let r2 = &s; // OK

// Mutable reference (exclusive)
let mut s = String::from("hello");
let r = &mut s;
r.push_str(" world");

// Cannot mix mut and immut refs
// let r1 = &s; let r2 = &mut s; // ERROR

// Pattern matching with Result
match result {
    Ok(val) => println!("Success: {}", val),
    Err(e) => eprintln!("Error: {}", e),
}

// if let for single pattern
if let Some(val) = optional {
    println!("{}", val);
}

// Iterator chains
let sum: i32 = vec![1, 2, 3, 4, 5]
    .iter()
    .filter(|&&x| x > 2)
    .map(|&x| x * x)
    .sum();

// Custom error type
#[derive(Debug)]
enum AppError {
    NotFound(String),
    Database(sqlx::Error),
    Validation(String),
}

impl From<sqlx::Error> for AppError {
    fn from(e: sqlx::Error) -> Self {
        AppError::Database(e)
    }
}

// Using thiserror crate
#[derive(thiserror::Error, Debug)]
enum AppError {
    #[error("not found: {0}")]
    NotFound(String),
}

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

// Enum variants as types
enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(r) => std::f64::consts::PI * r * r,
            Shape::Rectangle(w, h) => w * h,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    #[should_panic(expected = "overflow")]
    fn test_panic() {
        dangerous_operation();
    }

    #[test]
    fn test_result() -> Result<(), String> {
        let val = parse("42")?;
        assert_eq!(val, 42);
        Ok(())
    }
}