如何为持久化数据的MyVecTrait实现many_iter_mut可变迭代器？

问题 #

我定义了一个类似Vec的MyVecTrait trait，其实现者会将数据持久化到磁盘、数据库或缓存等存储介质中。目标是为该trait添加many_iter_mut()方法，接受索引列表并返回可变迭代器，通过调用实现者的get()和set()方法操作数据。但编写代码后遇到了Rust编译器的生命周期错误，且由于数据并非存储在内存中，无法使用unsafe块直接访问数据，必须调用实现者的set()方法。

代码示例 #

use std::collections::BTreeSet;
use std::iter::Iterator;

pub type Index = u64;

// Trait that defines some Vec operations.
pub trait MyVecTrait<T>
where
    T: Clone,
{
    fn get(&self, index: Index) -> Option<&T>;
    fn get_mut(&mut self, index: Index) -> Option<MySetter<Self, T>> {
        // can this clone on indexes by avoided?
        if let Some(value) = self.get(index).cloned() {
            Some(MySetter {
                vec: self,
                index,
                value,
            })
        } else {
            None
        }
    }
    fn set(&mut self, index: Index, value: T);

    /// return mutable iterator for elements matching indices
    fn many_iter_mut(
        &mut self,
        indices: impl IntoIterator<Item = Index> + 'static,
    ) -> ManyIterMut<Self, T>
    where
        Self: Sized,
    {
        ManyIterMut {
            data: self,
            indices: indices.into_iter().collect(),  // avoid collect if possible.
            phantom: Default::default(),
        }
    }
}

// This is a simple NewType that just wraps Vec and implements
// MyVecTrait.  A real-world impl would persist data to
// cache, file system, database, etc.

#[derive(Debug)]
pub struct SimpleVec<T>(Vec<T>);

impl<T: Clone> MyVecTrait<T> for SimpleVec<T> {
    fn get(&self, index: Index) -> Option<&T> {
        self.0.get(index as usize)
    }

    fn set(&mut self, index: Index, value: T) {
        self.0[index as usize] = value;
    }
}

// a mutating iterator for types that impl MyVecTrait
pub struct ManyIterMut<'a, V, T>
where
    V: MyVecTrait<T> + ?Sized,
    T: Clone,
{
    indices: BTreeSet<Index>, // Can this be a generic iterator?
    data: &'a mut V,

    phantom: std::marker::PhantomData<T>,
}

impl<'a, V, T: 'a> Iterator for ManyIterMut<'a, V, T>
where
    V: MyVecTrait<T>,
    T: Clone,
{
    type Item = MySetter<'a, V, T>;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(i) = self.indices.iter().next() {
            self.data.get_mut(*i)
        } else {
            None
        }
    }
}

/// setter returned from get_mut() and many_iter_mut()
/// use this to inspect and modify values.
pub struct MySetter<'a, V, T>
where
    V: MyVecTrait<T> + ?Sized,
    T: Clone,
{
    vec: &'a mut V,
    index: Index,
    value: T,
}

impl<'a, V, T> MySetter<'a, V, T>
where
    V: MyVecTrait<T> + ?Sized,
    T: Clone,
{
    pub fn set(&mut self, value: T) {
        self.vec.set(self.index, value);
    }

    pub fn value(&self) -> &T {
        &self.value
    }
}

fn main() {
    let mut v = SimpleVec(vec![100, 200, 300, 400, 500]);

    for mut setter in v.many_iter_mut([2, 3, 5]) {
        let val = setter.value();
        setter.set(*val + 1)
    }

    println!("modified vec: {:?}", v);
}

编译错误 #

error: lifetime may not live long enough
  --> src/main.rs:79:13
   |
70 | impl<'a, V, T: 'a> Iterator for ManyIterMut<'a, V, T>
   |      -- lifetime `'a` defined here
...
77 |     fn next(&mut self) -> Option<Self::Item> {
   |             - let's call the lifetime of this reference `'1`
78 |         if let Some(i) = self.indices.iter().next() {
79 |             self.data.get_mut(*i)
   |             ^^^^^^^^^^^^^^^^^^^^^ method was supposed to return data with lifetime `'a` but it is returning data with lifetime `'1`

解决方案 #

核心问题分析 #

编译错误的本质是：next方法只能借用ManyIterMut自身的可变引用（生命周期'1），但试图返回持有&'a mut V的MySetter——这会导致同一时间可能存在多个指向V的可变引用，违反Rust的借用规则。

方案1：调整迭代器逻辑，保证同一时间仅存在一个可变引用 #

通过将ManyIterMut中的data改为Option<&'a mut V>，在生成MySetter时暂时取出引用，待MySetter使用完毕后再放回迭代器，确保同一时间只有一个MySetter持有V的可变引用。

修改后的关键代码：

1. 调整ManyIterMut结构：

pub struct ManyIterMut<'a, V, T>
where
    V: MyVecTrait<T> + ?Sized,
    T: Clone,
{
    indices: std::collections::btree_set::IntoIter<Index>,
    data: Option<&'a mut V>,
    phantom: std::marker::PhantomData<T>,
}

2. 更新trait的many_iter_mut方法：

fn many_iter_mut(
    &mut self,
    indices: impl IntoIterator<Item = Index>,
) -> ManyIterMut<Self, T>
where
    Self: Sized,
{
    let indices_set: BTreeSet<_> = indices.into_iter().collect();
    ManyIterMut {
        data: Some(self),
        indices: indices_set.into_iter(),
        phantom: Default::default(),
    }
}

3. 重写Iterator实现：

impl<'a, V, T: 'a> Iterator for ManyIterMut<'a, V, T>
where
    V: MyVecTrait<T>,
    T: Clone,
{
    type Item = MySetter<'a, V, T>;

    fn next(&mut self) -> Option<Self::Item> {
        let index = self.indices.next()?;
        let data = self.data.take()?;
        let setter = data.get_mut(index)?;
        // 将引用放回迭代器，供下一次next调用使用
        self.data = Some(setter.vec);
        Some(setter)
    }
}

方案2：重构MySetter，避免直接持有V的可变引用 #

让MySetter通过闭包间接操作V，而非直接持有其可变引用，从而绕开生命周期冲突。

修改后的关键代码：

1. 重构MySetter结构：

pub struct MySetter<'a, V, T>
where
    V: MyVecTrait<T> + ?Sized,
    T: Clone,
{
    index: Index,
    value: T,
    set_fn: Box<dyn FnMut(Index, T) + 'a>,
}

impl<'a, V, T> MySetter<'a, V, T>
where
    V: MyVecTrait<T> + ?Sized,
    T: Clone,
{
    pub fn set(&mut self, value: T) {
        (self.set_fn)(self.index, value);
    }

    pub fn value(&self) -> &T {
        &self.value
    }
}

2. 更新trait的get_mut方法：

fn get_mut(&mut self, index: Index) -> Option<MySetter<Self, T>> {
    if let Some(value) = self.get(index).cloned() {
        let this = self as *mut Self;
        Some(MySetter {
            index,
            value,
            set_fn: Box::new(move |idx, val| unsafe {
                (*this).set(idx, val);
            }),
        })
    } else {
        None
    }
}

注意：此方案使用了unsafe块，需确保set_fn不会在V被销毁后调用，避免悬垂指针问题。

额外优化建议 #

• 若不需要索引去重，可将BTreeSet替换为直接使用迭代器（IntoIter），省去排序和内存开销；
• get_mut中的克隆操作对于持久化存储通常无法避免，但可考虑在trait中新增get_cloned方法，让实现者根据存储特性优化克隆逻辑。

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