Rust中带错误处理的映射拆分如何优化？替代collect+unzip方案

这个问题我太懂了——collect+unzip的链式调用确实会带来不必要的内存开销，导致性能折损，而且代码看起来也不够清爽。原方案里先把所有元素收集成Vec<(i32, i32)>，再拆分到两个向量，这个中间元组向量的分配和拷贝就是性能瓶颈所在。这里有两种更优的实现方式，既解决性能问题，又能保持代码的可读性：

直接手动遍历原列表，提前预分配两个目标向量的容量，避免中间内存分配和多次扩容：

fn main() -> Result<(), String> {
    let fallible1 = |num: &i32| -> Result<i32, String> { Ok(num + 1) };
    let fallible2 = |num: &i32| -> Result<i32, String> { Ok(num + 2) };
    let list = [1, 2, 3];

    // 预分配与原列表长度一致的容量，避免扩容开销
    let mut result = Vec::with_capacity(list.len());
    let mut intermediate = Vec::with_capacity(list.len());

    for elem in list.iter() {
        let inter_val = fallible1(elem)?;
        let res_val = fallible2(&inter_val)?;
        result.push(res_val);
        intermediate.push(inter_val);
    }

    // 这里可以使用result和intermediate
    Ok(())
}

这个方案完全消除了中间元组向量的开销，性能和纯命令式实现几乎一致，代码逻辑也非常直观，没有复杂的链式调用。

如果想保留迭代器的风格，不想写for循环，可以用fold来代替collect+unzip，在迭代过程中直接填充两个向量，同时处理错误：

fn main() -> Result<(), String> {
    let fallible1 = |num: &i32| -> Result<i32, String> { Ok(num + 1) };
    let fallible2 = |num: &i32| -> Result<i32, String> { Ok(num + 2) };
    let list = [1, 2, 3];

    let (result, intermediate) = list.iter()
        .fold(
            // 初始值：预分配好容量的两个向量的Result
            Ok((Vec::with_capacity(list.len()), Vec::with_capacity(list.len()))),
            |acc, elem| {
                let (mut res_vec, mut inter_vec) = acc?;
                let inter_val = fallible1(elem)?;
                let res_val = fallible2(&inter_val)?;
                res_vec.push(res_val);
                inter_vec.push(inter_val);
                Ok((res_vec, inter_vec))
            }
        )?;

    // 这里可以使用result和intermediate
    Ok(())
}

fold的方式既保持了迭代器的链式风格，又避免了中间元组向量的分配，性能和手动遍历相当，代码也比较整洁。

为什么原方案性能差？ #

原方案中，collect::<Result<Vec<(i32, i32)>, String>>()会先创建一个包含所有元组的向量，然后unzip又会遍历这个元组向量，把元素分别拷贝到两个新向量里——相当于做了两次遍历，还多分配了一次内存。而上面的两种方案都是一次遍历直接填充目标向量，内存开销和遍历次数都减半，自然性能提升明显。

内容的提问来源于stack exchange，提问作者Luuk Wester