复用带生命周期的Vec时，如何满足Rust借用检查器要求？

问题描述 #

我在Rust开发中常遇到如下模式：

struct Foo { /*...*/ }
struct FooProcessor {
    foos: Vec<&'??? mut Foo>, // 此处生命周期为核心问题
    // 处理Foo所需的其他数据结构....
}
impl FooProcessor {
    // 明确：`self`可能比`input`及其包含的`Foo`实例存活更久
    pub fn process(&mut self, input: &mut [Foo]) {
        // 示例操作：筛选Foo子集并随机访问
        self.foos.extend(input.iter_mut().filter(|f| f.some_property()));
        self.foos.sort(); 

        // 执行更多Foo处理操作...

        // 处理完成后清除所有Foo引用
        self.foos.clear();
    }
}

问题在于FooProcessor::foos的生命周期标注——尽管process()结束时会清空所有引用，但Rust借用检查器无法识别这一点。FooProcessor通常是长期存活的大型对象（存活时间可能超过部分Foo实例），我不想每次调用process()时重新分配Vec<&mut Foo>（甚至不想用SmallVec这类工具）。

请问有没有无需自行编写unsafe代码（允许使用内部含unsafe的第三方crate）的解决方案？

解决方案 #

方法1：类型状态机（零依赖纯安全Rust） #

通过类型状态区分处理器的两种状态：空闲态（无引用）和处理态（持有临时引用），让借用检查器能明确跟踪引用生命周期，同时重用Vec的内存分配。

代码示例：

struct Foo {
    some_flag: bool,
    // 其他字段...
}

impl Foo {
    fn some_property(&self) -> bool {
        self.some_flag
    }
}

// 空闲状态标记：处理器未持有任何Foo引用
struct Idle;
// 处理状态标记：处理器持有生命周期为'a的Foo引用
struct Processing<'a>;

// 泛型处理器，通过状态参数约束引用生命周期
struct FooProcessor<State> {
    foos: Vec<&'static mut Foo>, // 用'static占位，实际由状态参数约束
    // 其他长期存活的数据结构...
}

// 空闲态处理器的实现
impl FooProcessor<Idle> {
    fn new() -> Self {
        FooProcessor {
            foos: Vec::new(),
            // 初始化其他字段
        }
    }

    // 进入处理状态，绑定输入的生命周期，处理完成后返回空闲态
    fn process<'a>(mut self, input: &'a mut [Foo]) -> FooProcessor<Idle> {
        self.foos.clear(); // 重用已分配的Vec空间
        self.foos.extend(input.iter_mut().filter(|f| f.some_property()));
        self.foos.sort_by_key(|f| f.some_flag); // 示例排序逻辑

        // 执行具体的Foo处理操作...

        // 处理完成，返回空闲态处理器
        FooProcessor {
            foos: self.foos,
            // 保留其他字段
        }
    }
}

这种方式通过状态转换确保：只有在process方法执行期间，处理器才持有绑定到输入生命周期的引用；处理完成后自动回到无引用的空闲态，完全符合Rust的借用规则。

方法2：使用第三方crate（ouroboros） #

如果觉得类型状态机的写法繁琐，可以使用ouroboros crate——它通过宏安全实现自引用结构体，内部使用unsafe但对外暴露安全接口，帮你自动处理生命周期约束。

首先在Cargo.toml添加依赖：

ouroboros = "0.15"

实现代码：

use ouroboros::self_referencing;

struct Foo {
    some_flag: bool,
}

impl Foo {
    fn some_property(&self) -> bool {
        self.some_flag
    }
}

#[self_referencing]
struct FooProcessor {
    // 长期存活的其他数据结构
    // ...
    #[borrows]
    #[not_covariant]
    foos: Vec<&'this mut Foo>,
}

impl FooProcessor {
    fn new() -> Self {
        FooProcessorBuilder {
            // 初始化其他字段
            foos: Vec::new(),
        }.build()
    }

    pub fn process(&mut self, input: &mut [Foo]) {
        self.with_mut(|fields| {
            fields.foos.clear(); // 重用Vec空间
            fields.foos.extend(input.iter_mut().filter(|f| f.some_property()));
            fields.foos.sort_by_key(|f| f.some_flag);

            // 执行具体的Foo处理逻辑...
        });
    }
}

ouroboros会自动生成安全的结构体和方法，确保引用不会悬空，同时允许你重用Vec的内存分配。

方法3：Vec<Cell<Option<&mut Foo>>>（单线程变通方案） #

在单线程场景下，可以用Cell包裹引用的Option，手动管理引用的生命周期，从而重用Vec空间：

use std::cell::Cell;

struct Foo {
    some_flag: bool,
}

impl Foo {
    fn some_property(&self) -> bool {
        self.some_flag
    }
}

struct FooProcessor {
    foos: Vec<Cell<Option<&mut Foo>>>,
    // 其他数据结构...
}

impl FooProcessor {
    fn new() -> Self {
        FooProcessor {
            foos: Vec::new(),
        }
    }

    pub fn process(&mut self, input: &mut [Foo]) {
        // 重置所有Cell为None，清除旧引用
        self.foos.iter_mut().for_each(|c| c.set(None));
        
        // 计算需要的容量，按需扩容Vec
        let needed = input.iter().filter(|f| f.some_property()).count();
        if self.foos.len() < needed {
            self.foos.resize_with(needed, || Cell::new(None));
        }

        // 填充新的Foo引用
        let mut cell_iter = self.foos.iter_mut();
        input.iter_mut()
            .filter(|f| f.some_property())
            .for_each(|f| {
                cell_iter.next().unwrap().set(Some(f));
            });

        // 处理逻辑：访问时从Cell取出，处理完放回
        self.foos.iter()
            .take(needed)
            .for_each(|c| {
                if let Some(mut f) = c.take() {
                    // 执行Foo处理操作...
                    c.set(Some(f)); // 放回引用，避免悬空
                }
            });
    }
}

这种方式通过Cell的内部可变性绕过部分借用检查，但需要手动确保引用的生命周期安全，适合简单的单线程场景。

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