fn main() {
    // Simplest closure — no parameters, no return value
    let greet = || println!("Hello from a closure!");
    greet();

    // One parameter, inferred types
    let double = |x| x * 2;
    println!("double 5 = {}", double(5));

    // Explicit types and block body
    let add = |x: i32, y: i32| -> i32 {
        let sum = x + y;
        sum
    };
    println!("3 + 4 = {}", add(3, 4));
}

fn main() {
    let base = 10;

    // Closure captures 'base' from the enclosing scope
    let add_base = |x| x + base;

    println!("{}", add_base(5));    // 15
    println!("{}", add_base(20));   // 30

    // 'base' is still usable here because it was only borrowed
    println!("base is still: {}", base);
}

fn main() {
    // Immutable borrow — closure only reads 'greeting'
    let greeting = String::from("Hello");
    let print_greeting = || println!("{}", greeting);
    print_greeting();
    println!("still have: {}", greeting); // OK

    // Mutable borrow — closure modifies 'count'
    let mut count = 0;
    let mut increment = || {
        count += 1;
        println!("count: {}", count);
    };
    increment();
    increment();
    // println!("{}", count); // would error — mutably borrowed by closure
    drop(increment);          // closure dropped, borrow ends
    println!("final count: {}", count); // OK now

    // Move — closure takes ownership of 'data'
    let data = vec![1, 2, 3];
    let owns_data = move || println!("data: {:?}", data);
    owns_data();
    // println!("{:?}", data); // ERROR — data was moved into closure
}

use std::thread;

fn main() {
    let message = String::from("Hello from thread!");

    // Without 'move' this would not compile — the thread might outlive 'message'
    let handle = thread::spawn(move || {
        println!("{}", message);
    });

    handle.join().unwrap();
    // 'message' was moved — cannot use it here
}

fn call_once(f: impl FnOnce() -> String) -> String {
    f() // can only call f once
}

fn call_many_times(mut f: impl FnMut() -> i32) {
    println!("{}", f());
    println!("{}", f());
    println!("{}", f());
}

fn call_without_side_effects(f: impl Fn(i32) -> i32) -> i32 {
    f(1) + f(2) + f(3)
}

fn main() {
    // FnOnce — consumes 'name' by moving it into the return value
    let name = String::from("Alice");
    let greeting = call_once(|| format!("Hello, {}!", name));
    println!("{}", greeting);

    // FnMut — mutates captured counter
    let mut n = 0;
    call_many_times(|| { n += 1; n });
    println!("n is now: {}", n);

    // Fn — only reads 'factor'
    let factor = 3;
    let total = call_without_side_effects(|x| x * factor);
    println!("total: {}", total);
}

// impl Fn syntax — clean and idiomatic
fn apply_twice(f: impl Fn(i32) -> i32, x: i32) -> i32 {
    f(f(x))
}

// Generic syntax — equivalent, useful when the bound is shared across parameters
fn apply_twice_generic<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(f(x))
}

fn main() {
    let result = apply_twice(|x| x + 3, 10);
    println!("10 + 3 + 3 = {}", result);  // 16

    let result2 = apply_twice_generic(|x| x * 2, 5);
    println!("5 * 2 * 2 = {}", result2);  // 20
}

// impl Fn — zero overhead, type known at compile time
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
    move |x| x + n
}

// Box<dyn Fn> — needed when the return type varies at runtime
fn make_multiplier(double: bool) -> Box<dyn Fn(i32) -> i32> {
    if double {
        Box::new(|x| x * 2)
    } else {
        Box::new(|x| x * 3)
    }
}

fn main() {
    let add5 = make_adder(5);
    let add10 = make_adder(10);
    println!("add5(3) = {}", add5(3));   // 8
    println!("add10(3) = {}", add10(3)); // 13

    let f = make_multiplier(true);
    println!("double 7 = {}", f(7));     // 14

    let g = make_multiplier(false);
    println!("triple 7 = {}", g(7));     // 21
}

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

    // filter + map + collect
    let even_squares: Vec<i32> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * x)
        .collect();
    println!("even squares: {:?}", even_squares);

    // for_each
    numbers.iter()
        .filter(|&&x| x > 7)
        .for_each(|x| print!("{} ", x));
    println!();

    // sort_by — sort strings by length
    let mut words = vec!["banana", "apple", "fig", "cherry", "date"];
    words.sort_by(|a, b| a.len().cmp(&b.len()));
    println!("sorted by length: {:?}", words);

    // fold — sum with a starting value
    let sum: i32 = numbers.iter().fold(0, |acc, &x| acc + x);
    println!("sum: {}", sum);
}

fn main() {
    let mut items: Vec<i32> = vec![3, 1, 4, 1, 5];

    // This works — sort_by takes &self, items is not moved
    items.sort_by(|a, b| a.cmp(b));
    println!("sorted: {:?}", items);

    // Mutable closure borrows 'items' — cannot read 'items' during borrow
    let mut push_item = || items.push(99);
    push_item();
    // println!("{:?}", items); // would fail — mutable borrow still active
    drop(push_item);            // end the borrow
    println!("after push: {:?}", items);
}

struct Memoize<T, F>
where
    F: Fn(u32) -> T,
    T: Clone,
{
    func:  F,
    cache: Option<(u32, T)>,
}

impl<T, F> Memoize<T, F>
where
    F: Fn(u32) -> T,
    T: Clone,
{
    fn new(func: F) -> Self {
        Memoize { func, cache: None }
    }

    fn call(&mut self, arg: u32) -> T {
        match &self.cache {
            Some((cached_arg, cached_val)) if *cached_arg == arg => {
                println!("(cache hit for {})", arg);
                cached_val.clone()
            }
            _ => {
                println!("(computing for {})", arg);
                let result = (self.func)(arg);
                self.cache = Some((arg, result.clone()));
                result
            }
        }
    }
}

fn expensive(n: u32) -> u32 {
    // Simulate expensive work
    n * n + 1
}

fn main() {
    let mut memo = Memoize::new(expensive);
    println!("result: {}", memo.call(5));
    println!("result: {}", memo.call(5));  // cache hit
    println!("result: {}", memo.call(7));  // new computation
}

fn make_operation(op: &str) -> Box<dyn Fn(f64, f64) -> f64> {
    match op {
        "add" => Box::new(|a, b| a + b),
        "sub" => Box::new(|a, b| a - b),
        "mul" => Box::new(|a, b| a * b),
        "div" => Box::new(|a, b| if b != 0.0 { a / b } else { f64::NAN }),
        _     => Box::new(|_, _| 0.0),
    }
}

fn main() {
    let ops = ["add", "sub", "mul", "div"];
    for op in &ops {
        let f = make_operation(op);
        println!("{}: {}", op, f(10.0, 3.0));
    }
}

fn main() {
    // Short inline transformation
    let numbers = vec![1, 2, 3];
    let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();

    // Capture by reference for read-only work
    let threshold = 5;
    let big: Vec<_> = numbers.iter().filter(|&&x| x > threshold).collect();

    // move for thread safety
    let msg = String::from("hello");
    std::thread::spawn(move || println!("{}", msg)).join().unwrap();

    // Return a configured closure
    let add_100 = |x: i32| x + 100;
    println!("{}", add_100(42));

    // FnOnce — consume and transform
    let name = String::from("Rust");
    let shout = || format!("{}!", name.to_uppercase());
    println!("{}", shout());

    println!("doubled: {:?}", doubled);
    println!("big (>5): {:?}", big);
}