Rust 具有对同一类型的另一个实例的可变引用的

问题是，你不需要一辈子.即使是两个也帮不上忙.您需要无限多个生命周期或一组动态生命周期来跟踪每个动态子对象.这当然行不通.

据我所知，你想要的东西不能用铁 rust 来写.

有了不安全的铁 rust ，就有可能做得很好，只要你不会改变outer指针.这不安全的原因是编译器无法证明这一点.有两种方法可以解决这种不安全 rust 病的问题.一种是将父指针存储为原始指针:

use std::collections::HashMap;
use std::marker::PhantomData;
use std::ptr::NonNull;

struct Environment<'a> {
    outer: Option<NonNull<Environment<'a>>>,
    value: HashMap<i32, String>,
    _marker: PhantomData<&'a ()>,
}

// Needed because of the `NonNull`, safe as long as the keys and values are `Send` and `Sync`.
unsafe impl Send for Environment<'_> {}
unsafe impl Sync for Environment<'_> {}

impl<'a> Environment<'a> {
    fn new() -> Self {
        Self {
            outer: None,
            value: HashMap::new(),
            _marker: PhantomData,
        }
    }

    fn child<'b>(&'b mut self) -> Environment<'b> {
        Self {
            outer: Some(self.into()),
            value: HashMap::new(),
            _marker: PhantomData,
        }
    }
    
    fn map_depth(&self, depth: u32) -> Option<&HashMap<i32, String>> {
        unsafe {
            let mut this = NonNull::from(self);
            for _ in 0..depth {
                this = this.as_ref().outer?;
            }
            Some(&this.as_ref().value)
        }
    }
    
    fn map_depth_mut(&mut self, depth: u32) -> Option<&mut HashMap<i32, String>> {
        unsafe {
            let mut this = NonNull::from(self);
            for _ in 0..depth {
                this = this.as_mut().outer?;
            }
            Some(&mut this.as_mut().value)
        }
    }
}

另一种更安全的方法是使用内部可变性:就像将值包装在RefCell中一样，只需使用UnsafeCell而不是RefCell来避免运行时开销:

use std::cell::UnsafeCell;
use std::collections::HashMap;

struct Environment<'a> {
    outer: Option<&'a Environment<'a>>,
    value: UnsafeCell<HashMap<i32, String>>,
}

// Needed because of the `UnsafeCell`, safe as long as the keys and values are `Sync`.
unsafe impl Sync for Environment<'_> {}

impl<'a> Environment<'a> {
    fn new() -> Self {
        Self {
            outer: None,
            value: UnsafeCell::new(HashMap::new()),
        }
    }

    fn child<'b>(&'b mut self) -> Environment<'b> {
        Environment {
            outer: Some(self),
            value: UnsafeCell::new(HashMap::new()),
        }
    }

    fn map_depth(&self, depth: u32) -> Option<&HashMap<i32, String>> {
        let mut this: &Environment = self;
        for _ in 0..depth {
            this = this.outer?;
        }
        Some(unsafe { &*this.value.get() })
    }

    fn map_depth_mut(&mut self, depth: u32) -> Option<&mut HashMap<i32, String>> {
        let mut this: &Environment = self;
        for _ in 0..depth {
            this = this.outer?;
        }
        Some(unsafe { &mut *this.value.get() })
    }
}