Rust实现带错误处理的Option::get_or_insert_with遇双重借用问题

问题重现 #

尝试实现支持失败场景的Option::get_or_insert_with，初始代码如下：

fn fallible_get_or_insert_with(option: &mut Option<String>) -> Result<&mut String, &'static str> {
    if let Some(inner) = option.as_mut() {
        return Ok(inner);
    };

    let inner = if rand::random() {
        "Brand new inner value!".to_string()
    } else {
        return Err("Got unlucky");
    };

    Ok(option.insert(inner))
}

编译触发可变借用冲突错误：

error[E0499]: cannot borrow `*option` as mutable more than once at a time
  --> src/main.rs:12:8
   |
1  | fn fallible_get_or_insert_with(option: &mut Option<String>) -> Result<&mut String, &'static str> {
   |                                        - let's call the lifetime of this reference `'1`
2  |     if let Some(inner) = option.as_mut() {
   |                          ------ first mutable borrow occurs here
3  |         return Ok(inner);
   |                --------- returning this value requires that `*option` is borrowed for `'1`
...
12 |     Ok(option.insert(inner))
   |        ^^^^^^ second mutable borrow occurs here

For more information about this error, try `rustc --explain E0499`.

为什么会触发二次可变借用？ #

核心原因是Rust的借用检查器是静态、保守的代码分析工具，它不会跟踪运行时的分支执行结果，只会基于代码结构做全局约束：

• 当if let Some(inner) = option.as_mut()分支返回Ok(inner)时，inner作为option的可变引用，其生命周期被绑定到函数的返回值生命周期'1。
• 借用检查器会默认认为：整个函数执行期间，option都可能处于被'1生命周期覆盖的可变借用状态——哪怕实际走到第12行的分支时，as_mut()的引用早已失效，它也无法在编译时确认这一点，因此判定第12行的option.insert是二次可变借用。

简单来说：借用检查器的分析是函数级别的生命周期约束，而非分支级别的局部约束。

可行解决方案 #

方案1：is_none()判断配合unwrap() #

通过is_some()先判断状态，避免提前创建可变引用，后续的unwrap()是安全的（因为已经确认Option为Some）：

fn fallible_get_or_insert_with(option: &mut Option<String>) -> Result<&mut String, &'static str> {
    if option.is_some() {
        return Ok(option.as_mut().unwrap());
    }

    let inner = if rand::random() {
        "Brand new inner value!".to_string()
    } else {
        return Err("Got unlucky");
    };

    Ok(option.insert(inner))
}

方案2：模仿标准库用unwrap_unchecked()（unsafe） #

标准库的get_or_insert使用unwrap_unchecked()，是因为已经通过is_none()确认了Option的状态，可跳过运行时检查同时规避借用检查器的保守限制：

use std::ptr;

fn fallible_get_or_insert_with(option: &mut Option<String>) -> Result<&mut String, &'static str> {
    if option.is_none() {
        let inner = if rand::random() {
            "Brand new inner value!".to_string()
        } else {
            return Err("Got unlucky");
        };
        return Ok(option.insert(inner));
    }

    // 已通过is_none()反向确认是Some，unsafe操作安全
    unsafe { Ok(&mut *ptr::addr_of_mut!(option.as_mut().unwrap_unchecked())) }
}

本质原因总结 #

Rust借用检查器的保守性决定了它不会为特定分支放宽生命周期约束。只要函数存在返回option可变引用的分支，它就会将option的可变借用生命周期绑定到整个函数的返回值，导致后续可变操作冲突。而is_none()的方式因为没有提前创建可变引用，不会触发这个约束；标准库用unwrap_unchecked()则是在确认安全的前提下，绕过借用检查器的保守限制。

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