如何在不触发Rust借用检查器报错的情况下优雅实现代码DRY？

背景 #

有OOP开发背景，在为结构体实现各类trait和函数时尝试抽象逻辑，频繁遇到借用检查器报错，寻求Rust最佳实践，愿意调整架构适配Rust思维模式。

问题1：为trait实现者抽象通用逻辑 #

原始代码 #

首先定义trait MyContainer及结构体VecContainer的实现：

trait MyContainer<T> {
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>;
    fn check_value(&self, item: &T) -> bool;
}

struct VecContainer<T> {
    items: Vec<T>,
    checker: fn(&T) -> bool,
}

impl<T> MyContainer<T> for VecContainer<T> {
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
        self.items.iter_mut()
    }
    
    fn check_value(&self, item: &T) -> bool {
        (self.checker)(item)
    }
}

为VecContainer单独实现Checker trait时正常：

trait Checker<T> {
    fn check_all(&mut self) -> bool;
}

impl<T> Checker<T> for VecContainer<T> {
    fn check_all(&mut self) -> bool {
        self.items.iter_mut().all(|item| (self.checker)(item))
    }
}

但尝试为所有MyContainer实现者抽象Checker逻辑时，借用检查器报错：

impl<T, TImpl> Checker<T> for TImpl where TImpl: MyContainer<T> {
    fn check_all(&mut self) -> bool {
        // 报错：`self`先被`iter_mut()`可变借用，又被`check_value()`不可变借用
        self.iter_mut().all(|item| self.check_value(item))
    }
}

解决方案 #

核心问题是trait抽象中，编译器无法确认check_value不会修改self（即使方法签名是&self），也无法确认iter_mut返回的迭代器不会持有self的可变借用直到闭包执行完毕。解决思路是拆分对self的依赖：

方案1：分离检查逻辑到独立方法

修改MyContainer trait，添加一个获取检查器的方法，提前拿到检查逻辑后再进行迭代：

trait MyContainer<T> {
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>;
    // 新增：返回独立的检查函数，不需要依赖`&self`执行
    fn get_checker(&self) -> impl Fn(&T) -> bool;
}

// 更新VecContainer的实现
impl<T> MyContainer<T> for VecContainer<T> {
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
        self.items.iter_mut()
    }
    
    fn get_checker(&self) -> impl Fn(&T) -> bool {
        self.checker
    }
}

// 现在可以安全抽象Checker的实现
impl<T, TImpl> Checker<T> for TImpl where TImpl: MyContainer<T> {
    fn check_all(&mut self) -> bool {
        // 先获取检查器（不可变借用，随后释放）
        let checker = self.get_checker();
        // 再进行可变迭代，此时self仅被可变借用
        self.iter_mut().all(|item| checker(item))
    }
}

方案2：重构trait设计

如果检查逻辑不需要依赖容器自身状态，可以将check_value设计为trait的关联函数，或者将检查器作为trait的关联类型，彻底避免对self的依赖：

trait MyContainer<T> {
    type Checker: Fn(&T) -> bool;
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>;
    fn checker(&self) -> Self::Checker;
}

// VecContainer实现调整
impl<T> MyContainer<T> for VecContainer<T> {
    type Checker = fn(&T) -> bool;
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
        self.items.iter_mut()
    }
    fn checker(&self) -> Self::Checker {
        self.checker
    }
}

这种设计更清晰地分离了容器的迭代能力和检查逻辑，符合Rust的组合式思维。

问题2：抽象辅助函数时的多次可变借用 #

原始代码 #

VecContainer的complex_check方法在单次迭代中查找两个元素并修改，可正常运行：

trait Mutable {
    fn mutate(&mut self);
    fn compare(&self, other: &Self) -> bool;
}

impl<T> VecContainer<T> where T : Mutable {
    fn complex_check(&mut self, item1: &T, item2: &T) -> bool {
        let mut match1 = None;
        let mut match2 = None;

        for item in self.items.iter_mut() {
            if item.compare(item1) {
                match1 = Some(item);
            }
            else if item.compare(item2) {
                match2 = Some(item);
            }
        }

        if let (Some(match1), Some(match2)) = (match1, match2) {
            match1.mutate();
            match2.mutate();
            true
        }
        else {
            false
        }
    }
}

但将查找逻辑抽象为find_mut辅助函数后，两次调用会触发借用检查器报错：

impl<T> VecContainer<T> where T : Mutable {
    fn find_mut(&mut self, item: &T) -> Option<&mut T> {
        self.items.iter_mut().find(|i| i.compare(item))
    }

    fn complex_check(&mut self, item1: &T, item2: &T) -> bool {
        // 报错：两次可变借用`self`，违反Rust的借用规则
        let mut match1 = self.find_mut(item1);
        let mut match2 = self.find_mut(item2);

        if let (Some(match1), Some(match2)) = (match1, match2) {
            match1.mutate();
            match2.mutate();
            true
        }
        else {
            false
        }
    }
}

解决方案 #

Rust不允许同时存在多个对同一数据的可变引用，因此需要避免多次独立的可变借用。常见解决思路如下：

方案1：单次遍历完成多元素查找

将多个查找逻辑合并到一个辅助函数中，仅进行一次可变借用：

impl<T> VecContainer<T> where T : Mutable {
    // 新增：一次遍历查找两个目标元素
    fn find_two_mut(&mut self, item1: &T, item2: &T) -> Option<(&mut T, &mut T)> {
        let mut match1 = None;
        let mut match2 = None;

        for item in self.items.iter_mut() {
            if match1.is_none() && item.compare(item1) {
                match1 = Some(item);
            } else if match2.is_none() && item.compare(item2) {
                match2 = Some(item);
            }
            // 找到两个元素后提前退出
            if match1.is_some() && match2.is_some() {
                break;
            }
        }

        match (match1, match2) {
            (Some(a), Some(b)) => Some((a, b)),
            _ => None,
        }
    }

    fn complex_check(&mut self, item1: &T, item2: &T) -> bool {
        if let Some((match1, match2)) = self.find_two_mut(item1, item2) {
            match1.mutate();
            match2.mutate();
            true
        } else {
            false
        }
    }
}

这种方式既保留了代码复用性，又符合Rust的借用规则。

方案2：使用索引间接获取可变引用

如果元素可以通过索引访问，先查找目标元素的索引，再通过索引获取可变引用（需确保两个索引不同，避免同时借用同一元素）：

impl<T> VecContainer<T> where T : Mutable + PartialEq {
    fn find_index(&self, item: &T) -> Option<usize> {
        self.items.iter().position(|i| i.compare(item))
    }

    fn complex_check(&mut self, item1: &T, item2: &T) -> bool {
        let idx1 = self.find_index(item1);
        let idx2 = self.find_index(item2);

        if let (Some(i1), Some(i2)) = (idx1, idx2) {
            // 确保两个索引不同，避免可变引用重叠
            if i1 != i2 {
                // 通过split_at_mut安全获取两个不同的可变引用
                let (left, right) = self.items.split_at_mut(std::cmp::max(i1, i2));
                let (match1, match2) = if i1 < i2 {
                    (&mut left[i1], &mut right[0])
                } else {
                    (&mut right[0], &mut left[i2])
                };
                match1.mutate();
                match2.mutate();
                true
            } else {
                false
            }
        } else {
            false
        }
    }
}

这种方式适合需要单独查找索引的场景，但需要额外处理索引的有效性和唯一性。

方案3：内部可变性（仅作备选）

如果上述方案都无法适配，可以使用RefCell实现运行时的借用检查，但这会将编译时的错误推迟到运行时，仅在必要时使用：

use std::cell::RefCell;

struct VecContainer<T> {
    items: RefCell<Vec<T>>,
    checker: fn(&T) -> bool,
}

impl<T> VecContainer<T> where T : Mutable {
    fn find_mut(&self, item: &T) -> Option<std::cell::RefMut<'_, T>> {
        let mut items = self.items.borrow_mut();
        items.iter_mut().find(|i| i.compare(item)).map(|r| std::cell::RefMut::map(items, |v| r))
    }

    fn complex_check(&self, item1: &T, item2: &T) -> bool {
        let match1 = self.find_mut(item1);
        let match2 = self.find_mut(item2);

        if let (Some(mut match1), Some(mut match2)) = (match1, match2) {
            match1.mutate();
            match2.mutate();
            true
        } else {
            false
        }
    }
}

注意：内部可变性会带来运行时开销，且可能导致panic，除非确实需要共享可变状态，否则优先选择编译时安全的方案。

总结 #

这些问题是Rust中的常规场景，核心原因是Rust的借用检查器强制确保内存安全，避免数据竞争。从OOP切换到Rust思维的关键在于：

• 优先通过组合而非继承实现抽象
• 明确分离数据的所有权和借用关系
• 尽量在编译时解决借用问题，而非依赖运行时检查

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