Cookbook

fn main() {
    // Copy types - copied on assignment
    let x = 5;
    let y = x;  // x is copied, both valid
    println!("x: {}, y: {}", x, y);  // ✅ Works

    // Move types - ownership transferred
    let s1 = String::from("hello");
    let s2 = s1;  // s1 is moved
    // println!("{}", s1);  // ❌ Error: value moved
    println!("{}", s2);  // ✅ Works

    // Explicit clone for deep copy
    let s3 = String::from("world");
    let s4 = s3.clone();
    println!("s3: {}, s4: {}", s3, s4);  // ✅ Both valid
}

fn main() {
    let mut s = String::from("hello");

    // Multiple immutable borrows OK
    let r1 = &s;
    let r2 = &s;
    println!("{} and {}", r1, r2);
    // r1 and r2 no longer used after this point

    // Now mutable borrow OK
    let r3 = &mut s;
    r3.push_str(", world");
    println!("{}", r3);
}

fn process_data(data: &str) -> usize {
    data.len()  // Borrow doesn't extend beyond function
}

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }

    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part  // Returns borrowed data
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");

    let i = ImportantExcerpt {
        part: first_sentence,
    };

    println!("Excerpt: {}", i.part);
}

fn main() {
    let mut v = vec![1, 2, 3, 4, 5, 6];

    let (left, right) = v.split_at_mut(3);

    left[0] = 10;
    right[0] = 20;

    println!("{:?}", v);  // [10, 2, 3, 20, 5, 6]
}

// Custom implementation for understanding
fn split_at_mut_custom<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) {
    let len = slice.len();
    assert!(mid <= len);

    unsafe {
        let ptr = slice.as_mut_ptr();
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

use std::cell::RefCell;

struct MockMessenger {
    sent_messages: RefCell<Vec<String>>,
}

impl MockMessenger {
    fn new() -> MockMessenger {
        MockMessenger {
            sent_messages: RefCell::new(vec![]),
        }
    }

    fn send(&self, message: &str) {  // Takes &self, not &mut self
        self.sent_messages.borrow_mut().push(String::from(message));
    }

    fn messages(&self) -> Vec<String> {
        self.sent_messages.borrow().clone()
    }
}

fn main() {
    let messenger = MockMessenger::new();
    messenger.send("hello");
    messenger.send("world");

    println!("Messages: {:?}", messenger.messages());
}

use std::borrow::Cow;

fn capitalize_first(s: &str) -> Cow<str> {
    if s.is_empty() {
        return Cow::Borrowed(s);
    }

    let first_char = s.chars().next().unwrap();

    if first_char.is_uppercase() {
        Cow::Borrowed(s)  // No allocation
    } else {
        let capitalized = first_char.to_uppercase().to_string() + &s[1..];
        Cow::Owned(capitalized)  // Allocate only when needed
    }
}

fn main() {
    let unchanged = capitalize_first("Hello");  // Borrowed
    let changed = capitalize_first("hello");    // Owned

    println!("{}", unchanged);
    println!("{}", changed);
}

use thiserror::Error;

#[derive(Error, Debug)]
pub enum ConfigError {
    #[error("configuration file not found at {path}")]
    NotFound { path: String },

    #[error("invalid configuration: {0}")]
    Invalid(String),

    #[error("IO error")]
    Io(#[from] std::io::Error),

    #[error("parse error")]
    Parse(#[from] serde_json::Error),
}

fn load_config(path: &str) -> Result<String, ConfigError> {
    if !std::path::Path::new(path).exists() {
        return Err(ConfigError::NotFound {
            path: path.to_string(),
        });
    }

    let contents = std::fs::read_to_string(path)?;  // IO error auto-converted

    if contents.is_empty() {
        return Err(ConfigError::Invalid("empty file".to_string()));
    }

    Ok(contents)
}

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;  // Return error if open fails
    let mut username = String::new();
    file.read_to_string(&mut username)?;  // Return error if read fails
    Ok(username)
}

// Even shorter
fn read_username_short(path: &str) -> Result<String, io::Error> {
    std::fs::read_to_string(path)
}

fn main() {
    match read_username_from_file("user.txt") {
        Ok(name) => println!("Username: {}", name),
        Err(e) => eprintln!("Error reading username: {}", e),
    }
}

use anyhow::{Context, Result};
use std::fs;

fn process_file(path: &str) -> Result<String> {
    let contents = fs::read_to_string(path)
        .context(format!("Failed to read file: {}", path))?;

    let processed = contents.trim().to_uppercase();

    if processed.is_empty() {
        anyhow::bail!("File is empty after processing");
    }

    Ok(processed)
}

fn main() -> Result<()> {
    let result = process_file("config.txt")?;
    println!("Processed: {}", result);
    Ok(())
}

// Use panic! for programming bugs
fn get_item(index: usize, items: &[String]) -> &String {
    assert!(index < items.len(), "Index out of bounds");  // Panic
    &items[index]
}

// Use Result for recoverable errors
fn parse_port(s: &str) -> Result<u16, std::num::ParseIntError> {
    s.parse()
}

// Use Option for absence (not an error)
fn find_user(id: u32, users: &[(u32, String)]) -> Option<&String> {
    users.iter()
        .find(|(uid, _)| *uid == id)
        .map(|(_, name)| name)
}

fn main() {
    let items = vec!["a".to_string(), "b".to_string()];
    let item = get_item(0, &items);  // OK

    match parse_port("8080") {
        Ok(port) => println!("Port: {}", port),
        Err(e) => eprintln!("Invalid port: {}", e),
    }

    match find_user(1, &[(1, "Alice".to_string())]) {
        Some(name) => println!("Found: {}", name),
        None => println!("User not found"),
    }
}

use anyhow::{Context, Result};
use std::fs;

fn load_config() -> Result<String> {
    let home = std::env::var("HOME")
        .context("HOME environment variable not set")?;

    let config_path = format!("{}/.config/app.toml", home);

    fs::read_to_string(&config_path)
        .with_context(|| format!("Failed to read config from {}", config_path))?;

    // Set RUST_BACKTRACE=1 for backtrace
    Ok(String::new())
}

fn main() -> Result<()> {
    load_config()?;
    Ok(())
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    // Map: transform each element
    let squared: Vec<i32> = numbers.iter()
        .map(|x| x * x)
        .collect();

    // Filter: keep elements matching predicate
    let evens: Vec<i32> = numbers.iter()
        .filter(|x| *x % 2 == 0)
        .copied()
        .collect();

    // Filter + map
    let even_squares: Vec<i32> = numbers.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * x)
        .collect();

    // Fold: reduce to single value
    let sum: i32 = numbers.iter().sum();
    let product: i32 = numbers.iter().product();

    println!("Squared: {:?}", squared);
    println!("Evens: {:?}", evens);
    println!("Even squares: {:?}", even_squares);
    println!("Sum: {}, Product: {}", sum, product);
}

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();

    // Insert if absent
    scores.entry("Blue").or_insert(10);
    scores.entry("Blue").or_insert(50);  // Doesn't overwrite

    println!("{:?}", scores);  // {"Blue": 10}

    // Update based on old value
    let text = "hello world wonderful world";
    let mut word_count = HashMap::new();

    for word in text.split_whitespace() {
        let count = word_count.entry(word).or_insert(0);
        *count += 1;
    }

    println!("{:?}", word_count);  // {"hello": 1, "world": 2, "wonderful": 1}

    // Conditional insert with computation
    let mut cache = HashMap::new();
    let key = "expensive_key";

    let value = cache.entry(key)
        .or_insert_with(|| {
            println!("Computing expensive value");
            42  // Expensive computation
        });

    println!("Value: {}", value);
}

struct Counter {
    count: u32,
    max: u32,
}

impl Counter {
    fn new(max: u32) -> Counter {
        Counter { count: 0, max }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < self.max {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let counter = Counter::new(5);

    for num in counter {
        println!("{}", num);
    }

    // Using iterator methods
    let sum: u32 = Counter::new(5).sum();
    println!("Sum: {}", sum);

    let squares: Vec<u32> = Counter::new(5)
        .map(|x| x * x)
        .collect();
    println!("Squares: {:?}", squares);
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    let result: Vec<i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)      // Keep evens
        .map(|x| x * x)                // Square them
        .skip(1)                       // Skip first
        .take(2)                       // Take next 2
        .collect();

    println!("{:?}", result);  // [16, 36]

    // Enumerating
    for (i, val) in numbers.iter().enumerate() {
        println!("Index {}: {}", i, val);
    }

    // Zipping
    let letters = vec!['a', 'b', 'c'];
    let zipped: Vec<(i32, char)> = numbers.iter()
        .copied()
        .zip(letters.iter().copied())
        .collect();

    println!("{:?}", zipped);  // [(1, 'a'), (2, 'b'), (3, 'c')]
}

fn parse_numbers(strings: Vec<&str>) -> Result<Vec<i32>, std::num::ParseIntError> {
    strings.iter()
        .map(|s| s.parse::<i32>())
        .collect()
}

fn main() {
    let valid = vec!["1", "2", "3"];
    let invalid = vec!["1", "two", "3"];

    match parse_numbers(valid) {
        Ok(nums) => println!("Parsed: {:?}", nums),
        Err(e) => eprintln!("Error: {}", e),
    }

    match parse_numbers(invalid) {
        Ok(nums) => println!("Parsed: {:?}", nums),
        Err(e) => eprintln!("Error: {}", e),  // Stops at first error
    }
}

use std::thread;
use std::time::Duration;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {  // move captures v
        println!("Vector: {:?}", v);
        thread::sleep(Duration::from_millis(100));
        42
    });

    let result = handle.join().unwrap();  // Wait for thread
    println!("Thread returned: {}", result);

    // Scoped threads (no move needed if lifetime OK)
    let numbers = vec![1, 2, 3, 4, 5];

    thread::scope(|s| {
        s.spawn(|| {
            println!("First half: {:?}", &numbers[..numbers.len()/2]);
        });

        s.spawn(|| {
            println!("Second half: {:?}", &numbers[numbers.len()/2..]);
        });
    });  // All spawned threads joined here
}

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    // Spawn producer thread
    thread::spawn(move || {
        let vals = vec!["hi", "from", "the", "thread"];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_millis(500));
        }
    });

    // Receive in main thread
    for received in rx {
        println!("Got: {}", received);
    }

    // Multiple producers
    let (tx, rx) = mpsc::channel();
    let tx1 = tx.clone();

    thread::spawn(move || {
        tx.send("from first").unwrap();
    });

    thread::spawn(move || {
        tx1.send("from second").unwrap();
    });

    for received in rx.iter().take(2) {
        println!("Got: {}", received);
    }
}

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);

        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });  // Lock released here (Mutex guard dropped)

        handles.push(handle);
    }

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

    println!("Result: {}", *counter.lock().unwrap());  // 10
}

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

type Job = Box<dyn FnOnce() + Send + 'static>;

struct ThreadPool {
    workers: Vec<thread::JoinHandle<()>>,
    sender: mpsc::Sender<Job>,
}

impl ThreadPool {
    fn new(size: usize) -> ThreadPool {
        let (sender, receiver) = mpsc::channel();
        let receiver = Arc::new(Mutex::new(receiver));
        let mut workers = Vec::with_capacity(size);

        for _ in 0..size {
            let receiver = Arc::clone(&receiver);

            let handle = thread::spawn(move || loop {
                let job = receiver.lock().unwrap().recv();

                match job {
                    Ok(job) => job(),
                    Err(_) => break,
                }
            });

            workers.push(handle);
        }

        ThreadPool { workers, sender }
    }

    fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);
        self.sender.send(job).unwrap();
    }
}

fn main() {
    let pool = ThreadPool::new(4);

    for i in 0..8 {
        pool.execute(move || {
            println!("Task {} running", i);
        });
    }

    thread::sleep(std::time::Duration::from_secs(2));
}

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

async fn fetch_data(id: u32) -> String {
    sleep(Duration::from_millis(100)).await;
    format!("Data for {}", id)
}

#[tokio::main]
async fn main() {
    // Sequential
    let data1 = fetch_data(1).await;
    let data2 = fetch_data(2).await;
    println!("{}, {}", data1, data2);

    // Concurrent
    let (data1, data2) = tokio::join!(
        fetch_data(1),
        fetch_data(2)
    );
    println!("{}, {}", data1, data2);

    // Spawn tasks
    let task1 = tokio::spawn(fetch_data(1));
    let task2 = tokio::spawn(fetch_data(2));

    let data1 = task1.await.unwrap();
    let data2 = task2.await.unwrap();
    println!("{}, {}", data1, data2);
}

use std::fmt;

#[derive(Debug)]  // Auto-implement Debug
struct Point {
    x: i32,
    y: i32,
}

struct Circle {
    center: Point,
    radius: f64,
}

impl fmt::Debug for Circle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Circle")
            .field("center", &self.center)
            .field("radius", &self.radius)
            .finish()
    }
}

impl fmt::Display for Circle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Circle(center=({}, {}), radius={})",
               self.center.x, self.center.y, self.radius)
    }
}

fn main() {
    let circle = Circle {
        center: Point { x: 0, y: 0 },
        radius: 5.0,
    };

    println!("{:?}", circle);  // Debug
    println!("{}", circle);    // Display
}

struct Celsius(f64);
struct Fahrenheit(f64);

impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Fahrenheit {
        Fahrenheit(c.0 * 9.0 / 5.0 + 32.0)
    }
}

// Into is automatically implemented when From is
fn print_fahrenheit(temp: impl Into<Fahrenheit>) {
    let f: Fahrenheit = temp.into();
    println!("{}°F", f.0);
}

fn main() {
    let c = Celsius(100.0);
    let f: Fahrenheit = c.into();
    println!("{}°F", f.0);

    print_fahrenheit(Celsius(0.0));
}

struct Fibonacci {
    curr: u32,
    next: u32,
}

impl Fibonacci {
    fn new() -> Fibonacci {
        Fibonacci { curr: 0, next: 1 }
    }
}

impl Iterator for Fibonacci {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.curr + self.next;

        self.curr = self.next;
        self.next = new_next;

        Some(self.curr)
    }
}

fn main() {
    let fib = Fibonacci::new();

    for (i, num) in fib.take(10).enumerate() {
        println!("Fib {}: {}", i, num);
    }
}

#[derive(Debug)]
struct Config {
    host: String,
    port: u16,
    timeout: u64,
    retries: u32,
}

struct ConfigBuilder {
    host: String,
    port: u16,
    timeout: u64,
    retries: u32,
}

impl ConfigBuilder {
    fn new() -> ConfigBuilder {
        ConfigBuilder {
            host: String::from("localhost"),
            port: 8080,
            timeout: 30,
            retries: 3,
        }
    }

    fn host(mut self, host: &str) -> Self {
        self.host = host.to_string();
        self
    }

    fn port(mut self, port: u16) -> Self {
        self.port = port;
        self
    }

    fn timeout(mut self, timeout: u64) -> Self {
        self.timeout = timeout;
        self
    }

    fn build(self) -> Config {
        Config {
            host: self.host,
            port: self.port,
            timeout: self.timeout,
            retries: self.retries,
        }
    }
}

fn main() {
    let config = ConfigBuilder::new()
        .host("example.com")
        .port(9000)
        .build();

    println!("{:?}", config);
}

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use List::{Cons, Nil};

fn main() {
    let list = Cons(1,
        Box::new(Cons(2,
            Box::new(Cons(3,
                Box::new(Nil))))));

    // Large array on heap
    let large = Box::new([0; 1_000_000]);

    println!("Allocated {} bytes on heap", std::mem::size_of_val(&*large));
}