如何创建带可选同类型可变引用的非自引用Rust结构体

问题描述 #

想要创建一个包含可选可变引用到另一个同类型实例的结构体（非自引用，引用不同实例），尝试过两种写法均未成功：

第一种写法：

struct Environment<'a> {
    outer: Option<&'a mut Environment<'a>>,
    // 可替换为其他任意数据
    variables: HashMap<Identifier, Expression>, 
}

第二种写法：

struct Environment<'a, 'b> {
    outer: Option<&'a mut Environment<'b, 'b>>, //...
}

核心需求如下：

• 保持引用类型，实例存储在栈上，不使用Box
• 无额外运行时性能开销，不使用Rc/RefCell
• 可修改任意外层环境中的variables（或其他数据字段）
• 不能修改外层环境的outer指向，避免不安全操作
• 内部环境存在时，独占式可变借用外部环境（同一外部环境不能有多个子环境）

期望的用法示例（无法编译）：

struct Environment<'a> {
    outer: Option<&'a mut Environment<'a>>,
    value: i32,
}

impl<'a> Environment<'a> {
    fn new(value: i32) -> Self {
        Self { outer: None, value }
    }
    
    fn child<'b>(&'b mut self, value: i32) -> Environment<'b>
    where
        // 期望父环境生命周期长于子环境
        'a: 'b
    {
        Self { outer: Some(self), value }
    }
}

fn user_that_creates_child(env: &mut Environment) {
    let child_env = env.child(11);
    // 使用子环境
    child_env.outer.unwrap().value = 8; // 此操作应允许
    // child_env.outer.unwrap().outer = // 此操作应禁止
}

fn main() {
    let mut root_env = Environment::new(7);
}

编译器要求的生命周期约束与期望相反，需要where 'b: 'a，这是因为&mut T对T是逆变的，导致生命周期关系不符合需求。

解决方案 #

核心思路是拆分结构体，将可修改的数据与外层引用分离，既满足可变修改需求，又规避&mut T的逆变带来的生命周期冲突。

实现代码 #

use std::collections::HashMap;

// 仅包含可修改的数据字段，与外层引用解耦
#[derive(Default)]
struct EnvData {
    variables: HashMap<String, i32>, // 用String和i32替代业务中的Identifier和Expression
    value: i32,
}

// 环境结构体：持有对父环境数据的可变引用，以及自身的数据
struct Environment<'a> {
    outer_data: Option<&'a mut EnvData>,
    own_data: EnvData,
}

impl<'a> Environment<'a> {
    // 创建根环境（无外层引用）
    fn new(value: i32) -> Environment<'static> {
        Environment {
            outer_data: None,
            own_data: EnvData {
                variables: HashMap::new(),
                value,
            },
        }
    }

    // 创建子环境：独占式借用当前环境的自身数据
    fn child<'b>(&'b mut self, value: i32) -> Environment<'b>
    where
        'a: 'b, // 确保父环境生命周期长于子环境
    {
        Environment {
            outer_data: Some(&mut self.own_data),
            own_data: EnvData {
                variables: HashMap::new(),
                value,
            },
        }
    }

    // 示例：修改外层环境的value
    fn modify_parent_value(&mut self, new_value: i32) {
        if let Some(outer) = &mut self.outer_data {
            outer.value = new_value;
        }
    }

    // 示例：获取自身的value
    fn get_own_value(&self) -> i32 {
        self.own_data.value
    }

    // 示例：获取外层环境的value（可选）
    fn get_parent_value(&self) -> Option<i32> {
        self.outer_data.as_ref().map(|d| d.value)
    }
}

// 测试用法
fn user_that_creates_child(env: &mut Environment) {
    let mut child_env = env.child(11);
    // 修改父环境的value
    child_env.modify_parent_value(8);
    println!("父环境value修改后：{}", env.get_own_value()); // 输出8

    // 无法修改父环境的outer引用（因为outer_data不在EnvData中，子环境无法访问父的Environment结构体）
    // child_env.outer_data.unwrap().outer = ...; // 编译错误：EnvData中无outer字段
}

fn main() {
    let mut root_env = Environment::new(7);
    user_that_creates_child(&mut root_env);
}

方案满足的需求验证 #

• 栈存储与引用类型：EnvData和Environment均为栈上结构体，outer_data是引用类型，未使用Box
• 无额外运行时开销：未使用Rc/RefCell等智能指针，完全依赖Rust的借用检查
• 可修改外层数据：子环境通过outer_data可变引用可修改父环境的variables和value
• 禁止修改外层引用：子环境仅能访问父环境的EnvData，无法触及父的outer_data字段，从类型层面杜绝修改外层引用的可能
• 独占式借用：创建子环境时，父环境的own_data被&mut借用，同一父环境无法同时创建多个子环境，符合借用规则

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