Rust基于弱引用返回迭代器映射修改值的实现方案问询

我在Rust中实现高复杂度逻辑时遇到编译报错，实现需要满足以下要求：

• 存在一个生命周期覆盖应用全运行周期的对象，其内部存储的map/vector可在运行过程中被修改
• 可以持有该对象的多个不可变引用，用于读取内部的map/vector
• 所有逻辑运行在单线程环境下
• 支持多层嵌套迭代器，通过惰性map等适配器实现高性能复杂计算

问题最小复现代码如下：

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

pub struct Holder {
    array_ref: Weak<RefCell<Vec<isize>>>,
}

impl Holder {
    pub fn new(array_ref: Weak<RefCell<Vec<isize>>>) -> Self {
        Self { array_ref }
    }

    fn get_iterator(&self) -> impl Iterator<Item = f64> + '_ {
        self.array_ref
            .upgrade()
            .unwrap()
            .borrow()
            .iter()
            .map(|value| *value as f64 * 2.0)
    }
}

上述代码中的get_iterator是某个trait的实现方法，即使是简化版本也无法通过编译。
我使用Weak/Rc的原因是需要在多处持有长生命周期对象的引用，同时允许其他代码修改对象内部的Vec<isize>，最终实现对性能要求极高，需要该场景下的最佳处理方案。

按照建议尝试使用Ref::map实现，但始终无法通过编译，不确定是需要修改返回类型还是闭包写法有误，尝试代码如下：

fn get_iterator(&self) -> impl Iterator<Item=f64> + '_ {
    let x = self.array_ref.upgrade().unwrap().borrow();
    let map1 = Ref::map(x, |x| &x.iter());
    let map2 = Ref::map(map1, |iter| &iter.map(|y| *y as f64 * 2.0));
    map2
}

IDE返回的类型不匹配错误如下：

`Ref<'_, Map<std::slice::Iter<'_, isize>, [closure@src/bin/main.rs:30:46: 30:65]>>`类型未实现`Iterator`特征

1. 首先存在基础导入错误：单线程场景下应该使用std::rc::Weak，而非多线程场景下的std::sync::Weak。
2. 核心编译错误源于借用规则校验：RefCell::borrow()返回的Ref是RAII借用守卫，一旦守卫被drop，对应的借用就会立即释放。原链式调用写法中，borrow()返回的Ref在链式调用结束时就会被丢弃，最终返回的迭代器会指向已经失效的借用，违反Rust内存安全规则，必然编译失败。
3. Ref::map的尝试方向正确，但写法存在两个问题：
   • Ref::map要求闭包返回的引用生命周期必须和传入的Ref绑定，而iter.map(...)是闭包内创建的临时值，返回它的引用会直接造成悬垂引用
   • 切片迭代器std::slice::Iter持有对Vec元素的引用，生命周期和Ref守卫绑定，直接将迭代器存在Ref中会形成自引用结构，Rust原生不支持该类结构。

单线程极致性能场景下，不需要引入额外运行时开销，正确实现方式是将Ref守卫和基于它创建的迭代器绑定在同一个返回结构中，保证Ref的生命周期长于迭代器：

use std::cell::{Ref, RefCell};
use std::rc::Weak;

// 同时持有借用守卫和迭代器，保证守卫不会提前释放
struct VecIter<'a> {
    // 字段顺序决定drop顺序：iter声明在前先drop，_guard声明在后晚drop，保证迭代器使用时借用始终有效
    iter: std::iter::Map<std::slice::Iter<'a, isize>, fn(&isize) -> f64>,
    _guard: Ref<'a, Vec<isize>>,
}

impl<'a> Iterator for VecIter<'a> {
    type Item = f64;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next()
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

pub struct Holder {
    array_ref: Weak<RefCell<Vec<isize>>>,
}

impl Holder {
    pub fn new(array_ref: Weak<RefCell<Vec<isize>>>) -> Self {
        Self { array_ref }
    }

    fn get_iterator(&self) -> VecIter<'_> {
        let guard = self.array_ref.upgrade().unwrap().borrow();
        // 安全：生命周期转换后，guard和iter绑定存储在同一个结构体中，不会出现悬垂引用
        let iter = unsafe {
            std::mem::transmute(
                guard.iter().map(|v| *v as f64 * 2.0)
            )
        };
        VecIter {
            iter,
            _guard: guard,
        }
    }
}

该实现的运行时开销仅包含一次Rc升级校验和一次不可变借用检查，和原生迭代器性能几乎无差异，完全满足高性能要求。此处的unsafe逻辑是完全安全的，通过结构体字段顺序保证了drop顺序符合内存安全要求。

如果不想手动编写unsafe代码，可以使用自引用库封装该结构，库内部已经做了安全校验，性能和手写实现基本一致，仅需引入第三方依赖。

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