Rust中嵌套find返回None时如何终止map迭代并返回结果？

针对你的需求，我们可以利用Rust迭代器的try_fold方法结合windows来实现短路终止的链验证与成本累积，同时避免额外遍历结果向量的问题。以下是两种实现方式，分别适用于需要错误信息和仅需状态判断的场景：

方案一：带详细错误信息的实现 #

使用Result类型返回结果，遇到错误时终止迭代并返回具体错误原因：

use std::error::Error;

struct Thing {
    id: usize,
    cost: u32,
    numbers: Vec<usize>,
}

fn calculate_chain_cost(
    some_things: &[Thing],
    chain_of_things: &[usize],
) -> Result<u32, Box<dyn Error>> {
    // 处理空链的边界情况
    if chain_of_things.is_empty() {
        return Ok(0);
        // 若空链视为非法，可替换为：Err("Empty chain is not allowed".into())
    }

    // 获取链首元素的成本作为初始值，同时验证ID存在性
    let initial_cost = some_things
        .iter()
        .find(|t| t.id == chain_of_things[0])
        .ok_or(format!("Thing with id {} not found in some_things", chain_of_things[0]))?
        .cost;

    // 遍历连续ID对，用try_fold实现短路累积
    chain_of_things
        .windows(2)
        .try_fold(initial_cost, |total_cost, pair| {
            let &[prev_id, next_id] = pair else {
                return Err("Invalid pair in chain (unexpected length)".into());
            };

            // 查找前一个Thing实例
            let prev_thing = some_things
                .iter()
                .find(|t| t.id == prev_id)
                .ok_or(format!("Thing with id {} not found", prev_id))?;

            // 验证当前对是否可行
            if prev_thing.numbers.contains(&next_id) {
                // 查找后一个Thing并累加成本
                let next_cost = some_things
                    .iter()
                    .find(|t| t.id == next_id)
                    .ok_or(format!("Thing with id {} not found", next_id))?
                    .cost;
                Ok(total_cost + next_cost)
            } else {
                Err(format!(
                    "Pair ({}, {}) is invalid: {} does not reference {}",
                    prev_id, next_id, prev_id, next_id
                )
                .into())
            }
        })
}

fn main() -> Result<(), Box<dyn Error>> {
    let some_things = [
        Thing { id: 0, cost: 10, numbers: vec![1, 2] },
        Thing { id: 1, cost: 15, numbers: vec![3] },
        Thing { id: 2, cost: 20, numbers: vec![0, 1] },
        Thing { id: 3, cost: 5, numbers: vec![1] },
    ];
    
    // 测试有效链
    let valid_chain = [0, 1, 3];
    let total_cost = calculate_chain_cost(&some_things, &valid_chain)?;
    println!("Valid chain total cost: {}", total_cost); // 输出 30

    // 测试无效链
    let invalid_chain = [0, 3];
    match calculate_chain_cost(&some_things, &invalid_chain) {
        Err(e) => println!("Invalid chain error: {}", e),
        Ok(_) => println!("Unexpected success for invalid chain"),
    }

    Ok(())
}

方案二：简洁的Option实现（无详细错误信息） #

如果仅需判断链是否有效，无需具体错误原因，可使用Option类型简化代码：

struct Thing {
    id: usize,
    cost: u32,
    numbers: Vec<usize>,
}

fn calculate_chain_cost(some_things: &[Thing], chain_of_things: &[usize]) -> Option<u32> {
    if chain_of_things.is_empty() {
        return Some(0);
    }

    // 获取初始成本，ID不存在则返回None
    let initial_cost = some_things.iter().find(|t| t.id == chain_of_things[0])?.cost;

    chain_of_things.windows(2).try_fold(initial_cost, |total, pair| {
        let &[prev_id, next_id] = pair else { return None; };
        let prev_thing = some_things.iter().find(|t| t.id == prev_id)?;
        
        if prev_thing.numbers.contains(&next_id) {
            let next_cost = some_things.iter().find(|t| t.id == next_id)?.cost;
            Some(total + next_cost)
        } else {
            None
        }
    })
}

fn main() {
    let some_things = [
        Thing { id: 0, cost: 10, numbers: vec![1, 2] },
        Thing { id: 1, cost: 15, numbers: vec![3] },
        Thing { id: 2, cost: 20, numbers: vec![0, 1] },
        Thing { id: 3, cost: 5, numbers: vec![1] },
    ];

    if let Some(cost) = calculate_chain_cost(&some_things, &[0, 1, 3]) {
        println!("Total cost: {}", cost);
    } else {
        println!("Invalid chain");
    }
}

方案优势对比原实现 #

1. 短路终止：try_fold遇到Err或None时会立即停止迭代，无需遍历整个链。
2. 无需额外检查：直接返回Result或Option，调用方可以直接判断结果合法性，无需遍历结果向量查找特殊值。
3. 代码更简洁安全：用windows(2)替代手动索引操作，避免了索引越界风险，逻辑更直观。
4. 鲁棒性更强：新增了ID存在性验证，避免因链中ID不存在导致的索引panic。

内容的提问来源于stack exchange，提问作者ahul-fell-awen