闭包与迭代器 #

fn main() {
    let add = |a, b| a + b;
    
    println!("1 + 2 = {}", add(1, 2));
}

fn main() {
    let add = |a: i32, b: i32| -> i32 {
        a + b
    };
    
    println!("Result: {}", add(1, 2));
}

fn main() {
    let x = 10;
    
    let add_x = |a| a + x;
    
    println!("5 + x = {}", add_x(5));  // 15
}

fn main() {
    let mut s = String::from("hello");
    
    // FnMut: 可变借用
    let mut append = || {
        s.push_str(" world");
    };
    append();
    println!("{}", s);
    
    // Fn: 不可变借用
    let print = || {
        println!("{}", s);
    };
    print();
    
    // FnOnce: 消费
    let consume = || {
        let _ = s;
    };
    consume();
    // println!("{}", s);  // 错误：s 已被消费
}

fn main() {
    let s = String::from("hello");
    
    let print = move || {
        println!("{}", s);
    };
    
    print();
    // println!("{}", s);  // 错误：s 已被移动
}

fn apply<F>(f: F, x: i32) -> i32
where
    F: Fn(i32) -> i32,
{
    f(x)
}

fn main() {
    let double = |x| x * 2;
    
    let result = apply(double, 5);
    println!("Result: {}", result);
}

fn create_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

fn main() {
    let add_5 = create_adder(5);
    
    println!("5 + 3 = {}", add_5(3));
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // iter(): 不可变引用
    for x in v.iter() {
        print!("{} ", x);
    }
    println!();
    
    // iter_mut(): 可变引用
    let mut v2 = vec![1, 2, 3];
    for x in v2.iter_mut() {
        *x *= 2;
    }
    println!("{:?}", v2);
    
    // into_iter(): 获取所有权
    for x in v.into_iter() {
        print!("{} ", x);
    }
    println!();
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // sum
    let sum: i32 = v.iter().sum();
    println!("Sum: {}", sum);
    
    // product
    let product: i32 = v.iter().product();
    println!("Product: {}", product);
    
    // count
    let count = v.iter().count();
    println!("Count: {}", count);
    
    // collect
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    println!("Doubled: {:?}", doubled);
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // map
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    println!("Doubled: {:?}", doubled);
    
    // filter
    let evens: Vec<&i32> = v.iter().filter(|x| *x % 2 == 0).collect();
    println!("Evens: {:?}", evens);
    
    // take
    let first_three: Vec<&i32> = v.iter().take(3).collect();
    println!("First three: {:?}", first_three);
    
    // skip
    let skip_two: Vec<&i32> = v.iter().skip(2).collect();
    println!("Skip two: {:?}", skip_two);
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // find
    let first_even = v.iter().find(|x| *x % 2 == 0);
    println!("First even: {:?}", first_even);
    
    // position
    let pos = v.iter().position(|x| *x == 3);
    println!("Position of 3: {:?}", pos);
    
    // any
    let has_even = v.iter().any(|x| x % 2 == 0);
    println!("Has even: {}", has_even);
    
    // all
    let all_positive = v.iter().all(|x| *x > 0);
    println!("All positive: {}", all_positive);
}

fn main() {
    let mut v = vec![3, 1, 4, 1, 5, 9, 2, 6];
    
    // sort
    v.sort();
    println!("Sorted: {:?}", v);
    
    // sort_by
    v.sort_by(|a, b| b.cmp(a));
    println!("Reverse: {:?}", v);
    
    // min / max
    let min = v.iter().min();
    let max = v.iter().max();
    println!("Min: {:?}, Max: {:?}", min, max);
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    
    // fold
    let sum = v.iter().fold(0, |acc, x| acc + x);
    println!("Sum: {}", sum);
    
    // reduce
    let product = v.iter().reduce(|acc, x| acc * x);
    println!("Product: {:?}", product);
}

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let result: Vec<i32> = v
        .iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 2)
        .take(3)
        .collect();
    
    println!("Result: {:?}", result);  // [4, 8, 12]
}

#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}

fn main() {
    let people = vec![
        Person { name: String::from("Alice"), age: 30 },
        Person { name: String::from("Bob"), age: 25 },
        Person { name: String::from("Charlie"), age: 35 },
        Person { name: String::from("David"), age: 20 },
    ];
    
    let names: Vec<&str> = people
        .iter()
        .filter(|p| p.age >= 25)
        .map(|p| p.name.as_str())
        .collect();
    
    println!("Names: {:?}", names);
}

use std::collections::HashMap;

fn main() {
    let words = vec!["apple", "banana", "apple", "cherry", "banana", "apple"];
    
    let counts: HashMap<&str, usize> = words
        .iter()
        .fold(HashMap::new(), |mut acc, &word| {
            *acc.entry(word).or_insert(0) += 1;
            acc
        });
    
    println!("Counts: {:?}", counts);
}

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

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

impl Iterator for Counter {
    type Item = usize;
    
    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);
    }
}