如何在不使用RefCell的情况下重构Rust递归Port结构？

要绕开Rust借用规则限制，同时不使用RefCell这类标准库组件，最稳妥的方案是放弃直接引用关联，改用整数索引指向统一容器内的Port实例。以下是具体实现：

核心实现 #

定义Port与容器结构 #

// 单个Port，source存储目标Port在容器中的索引
struct Port<T> {
    value: T,
    source: Option<usize>,
}

// 管理所有Port的容器，这里用固定大小数组（可替换为自定义动态数组）
struct PortContainer<T, const N: usize> {
    ports: [Option<Port<T>>; N],
}

impl<T, const N: usize> PortContainer<T, N> {
    // 创建空容器，依赖Rust的const初始化能力
    const fn new() -> Self {
        PortContainer { ports: [None; N] }
    }

    // 向容器添加Port，返回其索引
    fn add_port(&mut self, value: T, source: Option<usize>) -> Result<usize, ()> {
        for (idx, slot) in self.ports.iter_mut().enumerate() {
            if slot.is_none() {
                *slot = Some(Port { value, source });
                return Ok(idx);
            }
        }
        Err(()) // 容器已满
    }

    // 修改指定索引Port的value
    fn update_value(&mut self, idx: usize, new_value: T) -> Result<(), ()> {
        match &mut self.ports[idx] {
            Some(port) => {
                port.value = new_value;
                Ok(())
            }
            None => Err(()), // 索引无效
        }
    }

    // 获取Port的当前value（不可变引用）
    fn get_value(&self, idx: usize) -> Option<&T> {
        self.ports[idx].as_ref().map(|p| &p.value)
    }

    // 递归遍历source链，获取最终的value
    fn get_chain_value(&self, idx: usize) -> Option<&T> {
        let mut current_idx = idx;
        loop {
            let port = self.ports[current_idx].as_ref()?;
            match port.source {
                Some(next_idx) => current_idx = next_idx,
                None => return Some(&port.value),
            }
        }
    }
}

使用示例 #

fn main() {
    // 初始化一个最多容纳3个Port的容器
    let mut container = PortContainer::<i32, 3>::new();

    // 添加一个无依赖的基础Port
    let base_idx = container.add_port(10, None).unwrap();
    // 添加依赖基础Port的子Port
    let dep_idx = container.add_port(0, Some(base_idx)).unwrap();

    // 修改基础Port的value
    container.update_value(base_idx, 20).unwrap();

    // 验证依赖链的最终值已更新
    assert_eq!(container.get_chain_value(dep_idx), Some(&20));
}

方案优势 #

1. 完全规避借用冲突：索引是拷贝类型，不存在引用生命周期限制，Port间的关联通过间接索引实现，彻底解决已引用Port无法修改的问题。
2. 无标准库依赖：所有逻辑基于Rust核心语法实现，不需要RefCell、Vec等标准库组件。
3. 拓扑灵活：支持任意递归关联拓扑（包括循环引用），不像基于所有权的递归结构只能支持单向树形。

备选方案：所有权式递归结构（有限场景适用） #

如果你的递归结构是单向树形（每个Port最多被一个其他Port引用），可以用Box实现所有权转移的递归结构，修改时直接操作可变引用：

struct Port<T> {
    value: T,
    source: Option<Box<Port<T>>>,
}

impl<T> Port<T> {
    fn update_value(&mut self, new_value: T) {
        self.value = new_value;
    }

    // 递归修改source的value
    fn update_source_value(&mut self, new_value: T) {
        if let Some(source) = &mut self.source {
            source.update_value(new_value);
        }
    }
}

但此方案不支持共享引用，仅适用于无分支的递归结构，通用性远不如索引容器方案。

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