迭代器与函数式风格

let mut errs: Vec<String> = Vec::new();
for line in log.lines() {
    if line.starts_with("ERROR") {
        errs.push(line.to_string());
    }
}

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    // 其余方法全部有默认实现
}

let v = vec![1, 2, 3];
let iter = v.iter().map(|x| {
    println!("map 处理 {x}");
    x * 2
});
println!("管道已建好，还没输出任何 map 行");
let sum: i32 = iter.sum();   // 此刻才逐个打印 1 2 3
println!("sum = {sum}");

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

    let result: Vec<i32> = nums
        .iter()          // 创建迭代器（借用）
        .filter(|x| *x % 2 == 0)  // 过滤出偶数
        .map(|x| x * 10)          // 每个数乘 10
        .collect();               // 收集为 Vec
    println!("{result:?}");       // [20, 40, 60]
}

let names = vec!["订单A", "订单B"];
let amounts = vec![120, 88];

// zip：两条序列按位拉链成对
let pairs: Vec<(&str, i32)> = names.iter().zip(amounts.iter()).collect();
println!("{pairs:?}");   // [("订单A", 120), ("订单B", 88)]

// chain：两条序列首尾相接
let all: Vec<i32> = vec![1, 2].into_iter().chain(vec![3, 4]).collect();
println!("{all:?}");     // [1, 2, 3, 4]

// 链式示例：求前 5 个正数的平方和
let nums = vec![-3, -1, 0, 2, 4, 6, 8];
let sum: i32 = nums.iter()
    .filter(|x| **x > 0)
    .take(5)
    .map(|x| x * x)
    .sum();
println!("{sum}");   // 2^2+4^2+6^2+8^2 = 120

let nums = vec![1, 2, 3, 4, 5, 6];

// 聚合操作
let sum: i32 = nums.iter().sum();        // 21
let max = nums.iter().max().unwrap();    // 6
let any = nums.iter().any(|x| x > 5);    // true
println!("{sum} {max} {any}");

// fold：带初值的通用归约
let product = nums.iter().fold(1, |acc, x| acc * x);   // 720

let v1: Vec<i32> = (0..5).collect();        // 类型写在变量上
let v2 = (0..5).collect::<Vec<i32>>();      // 或 turbofish 就地标注
let s = (0..5).collect::<String>();         // 数字字符串拼接

let threshold = 50;
let big: Vec<_> = nums.iter()
    .filter(|x| **x > threshold)   // 闭包捕获外部变量 threshold（借用）
    .collect();

use std::collections::HashMap;

#[derive(Debug)]
struct SlowReq<'a> {
    url: &'a str,
    cost_secs: f64,
}

fn analyze(log: &str) -> (HashMap<&str, usize>, Vec<SlowReq>) {
    let mut codes: HashMap<&str, usize> = HashMap::new();

    let mut slow: Vec<SlowReq> = log
        .lines()                                          // 迭代器入口：按行
        .filter(|l| l.contains("\" 5"))                   // 先粗筛 5xx 行
        .map(parse_line)                                  // 适配器：行 -> 结构体
        .filter(|r| r.cost_secs > 1.0)                    // 再筛慢请求
        .collect();                                       // 消费器：先收集
    slow.sort_by(|a, b| b.cost_secs.total_cmp(&a.cost_secs));
    slow.truncate(5);                                     // 取前 5

    for line in log.lines() {
        if let Some(code) = line.split_whitespace().nth(8) {
            *codes.entry(code).or_insert(0) += 1;
        }
    }
    (codes, slow)
}

fn parse_line(l: &str) -> SlowReq {
    // 真实解析见文件 IO 一篇的完整版；此处示意取 URL 与耗时
    let url = l.split('"').nth(1).unwrap_or("unknown");
    let cost = l.rsplit(' ').next().and_then(|c| c.trim_end_matches('"').parse().ok()).unwrap_or(0.0);
    SlowReq { url, cost_secs: cost }
}

struct CartItem {
    name: String,
    price: f64,
    qty: u32,
    valid: bool,
}

fn checkout(items: &[CartItem]) -> (f64, bool) {
    let subtotal: f64 = items.iter()
        .filter(|it| it.valid)                  // 只算有效商品
        .map(|it| it.price * it.qty as f64)     // 小计
        .sum();                                 // 金额汇总

    let over_stock = items.iter()
        .any(|it| it.qty > 99);                 // 存在性判断，短路

    (subtotal, over_stock)
}

fn main() {
    let cart = vec![
        CartItem { name: "键盘".into(), price: 299.0, qty: 1, valid: true },
        CartItem { name: "鼠标".into(), price: 99.0, qty: 2, valid: true },
        CartItem { name: "下架商品".into(), price: 50.0, qty: 1, valid: false },
    ];
    let (total, over) = checkout(&cart);
    println!("应付 {total}，超库存：{over}");   // 应付 497，超库存：false
}

#[derive(Debug)]
struct Row<'a> {
    name: &'a str,
    dept: &'a str,
    salary: u32,
}

fn parse_row(l: &str) -> Option<Row> {
    let mut it = l.split(',');
    let name = it.next()?;
    let dept = it.next()?;
    let salary = it.next()?.trim().parse().ok()?;
    Some(Row { name, dept, salary })
}

fn main() {
    let csv = "姓名,部门,工资\n张三,研发,20000\n李四,研发,24000\n王五,销售,15000\n\n赵六,销售,not-a-number";
    let rows: Vec<Row> = csv.lines()
        .skip(1)                    // 跳过表头
        .filter(|l| !l.trim().is_empty())
        .filter_map(parse_row)      // 解析失败的行被静默过滤
        .collect();

    let mut depts = std::collections::HashMap::new();
    for r in &rows {
        let e = depts.entry(r.dept).or_insert((0u64, 0u32));
        e.0 += r.salary as u64; e.1 += 1;
    }
    for (d, (sum, n)) in &depts {
        println!("{d}: 平均 {}", sum / *n as u64);
    }
}