Rust for循环修改元素时的借用错误与临时值引用问题求解

最初版本报错原因 #

• 函数签名中生命周期标注'a悬空，没有和任何输入参数绑定，违反Rust生命周期规则：返回引用的生命周期必须来源于输入参数的生命周期。
• 迭代器&mut foos会持有整个Vec的可变借用，且你把检查得到的引用存入了函数结束才返回的bar变量，导致该可变借用被延长到整个函数生命周期，下一轮循环无法再次获取Vec的可变借用，触发编译错误。

Rc版本报错原因 #

• foo.borrow()返回的是Ref<'_, Foo>类型的临时守卫，该临时值在当前语句结束后就会销毁，你将该临时值的引用传入check_foo得到的返回值，生命周期和临时守卫绑定，无法存活到函数返回。
• 输入参数foos是当前函数栈上的局部变量，函数执行结束后就会被回收，持有它的引用返回属于悬垂引用，Rust借用检查器会禁止该行为。

方案1：索引遍历（无额外开销，最推荐） #

直接用索引代替迭代器遍历Vec，单次循环只借用单个元素，不会延长整个Vec的借用周期，同时修正生命周期标注：

#[derive(Clone, Debug, PartialEq)]
pub struct Foo {
    updated: bool,
}

// 示例中check_foo返回的是静态常量，所以标注返回'static生命周期即可
fn run(mut foos: Vec<Foo>) -> Vec<&'static u32> {
    let mut bar: Vec<&u32> = vec![];

    for _num in 0..10 {
        // 用索引遍历代替迭代器
        for i in 0..foos.len() {
            let foo = &mut foos[i];
            update_foo(foo);

            let checked_foo = check_foo(foo);
            if checked_foo.is_empty() {
                bar = checked_foo;
                break;
            }
        }
    }

    bar
}

fn update_foo(foo: &mut Foo) {
    foo.updated = true
}

fn check_foo(foo: &Foo) -> Vec<&'static u32> {
    if foo.updated {
        vec![&0, &1, &2]
    } else {
        vec![]
    }
}

如果你的实际场景中check_foo返回的是Foo内部字段的引用，修改函数签名绑定输入输出生命周期即可：

// 输入的&'a mut Vec<Foo>生命周期和返回值绑定
fn run<'a>(foos: &'a mut Vec<Foo>) -> Vec<&'a u32> {
    // 内部逻辑不变
}

方案2：Rc版本修正 #

如果你的业务逻辑必须使用Rc，显式标注check_foo返回静态生命周期即可解决临时值引用问题：

use std::rc::Rc;
use std::cell::RefCell;

#[derive(Clone, Debug, PartialEq)]
pub struct Foo {
    updated: bool,
}

fn run(foos: Vec<Rc<RefCell<Foo>>>) -> Vec<&'static u32> {
    let mut bar: Vec<&u32> = vec![];

    for _num in 0..10 {
        for foo in &foos {
            update_foo(&mut foo.borrow_mut());

            let checked_foo = check_foo(&foo.borrow());
            if checked_foo.is_empty() {
                bar = checked_foo;
                break;
            }
        }
    }

    bar
}

fn update_foo(foo: &mut Foo) {
    foo.updated = true
}

// 显式标注返回静态生命周期，不和输入的临时守卫生命周期绑定
fn check_foo(_foo: &Foo) -> Vec<&'static u32> {
    if _foo.updated {
        vec![&0, &1, &2]
    } else {
        vec![]
    }
}

可以通过无副作用的迭代器组合子实现需求，不需要可变变量、也不需要提前break的命令式逻辑：

#[derive(Clone, Debug, PartialEq)]
pub struct Foo {
    updated: bool,
}

fn run(foos: Vec<Foo>) -> Vec<&'static u32> {
    // 遍历0..10的范围，找到第一个符合条件的结果直接返回
    (0..10).find_map(|_| {
        // 生成更新后的新Foo数组，无副作用
        let new_foos: Vec<Foo> = foos.iter()
            .map(|foo| {
                let mut new_foo = foo.clone();
                update_foo(&mut new_foo);
                new_foo
            })
            .collect();
        // 检查所有Foo，找到第一个符合条件的返回
        new_foos.iter().find_map(|foo| {
            let checked = check_foo(foo);
            if checked.is_empty() {
                Some(checked)
            } else {
                None
            }
        })
    }).unwrap_or_default()
}

fn update_foo(foo: &mut Foo) {
    foo.updated = true
}

fn check_foo(_foo: &Foo) -> Vec<&'static u32> {
    if _foo.updated {
        vec![&0, &1, &2]
    } else {
        vec![]
    }
}

该实现完全遵循纯函数式规范：没有可变外部变量、没有修改输入参数、相同输入永远得到相同输出，同时迭代器的find_map会在找到第一个符合条件的结果时立即终止遍历，满足提前返回的需求。

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