Rust 匹配和借用检查器

Question

我一直在我的 Rust 程序中偶然发现一个模式，这总是让我与借用检查器发生冲突。考虑以下玩具示例：

use std::sync::{Arc,RwLock};

pub struct Test {
    thing: i32,
}

pub struct Test2 {
    pub test: Arc<RwLock<Test>>,
    pub those: i32,
}

impl Test {
    pub fn foo(&self) -> Option<i32> {
        Some(3)
    }
}

impl Test2 {
    pub fn bar(&mut self) {
        let mut test_writer = self.test.write().unwrap();

        match test_writer.foo() {
            Some(thing) => {
                self.add(thing);
            },
            None => {}
        }
    }

    pub fn add(&mut self, addme: i32) {
        self.those += addme;
    }
}

这不会编译，因为 Some 分支中的 add 函数试图可变地借用 self，它已经在 match 语句上方不可变地借用以打开读写锁。

我在 Rust 中遇到过几次这种模式，主要是在使用 RwLock 时。我还找到了一种解决方法，即在 match 语句之前引入一个布尔值，然后更改 Some 臂中布尔值的值，然后最后在 match 语句之后对该布尔值引入一个测试以执行任何操作是我想在Some 手臂上做的。

在我看来这不是解决问题的方法，我认为在 Rust 中有一种更惯用的方法来做到这一点 - 或者以完全不同的方式解决问题 - 但我找不到它。如果我没记错的话，这个问题与词法借用有关，所以self 不能在匹配语句的范围内可变地借用。

有没有一种惯用的 Rust 方法来解决这类问题？

Answer 1

直接使用字段those，例如自定义类型：

use std::sync::{Arc,RwLock};

pub struct Those(i32);

impl Those {
    fn get(&self) -> i32 {
        self.0
    }

    fn add(&mut self, n: i32) {
        self.0 += n;
    }
}

pub struct Test {
    thing: Those,
}

pub struct Test2 {
    pub test: Arc<RwLock<Test>>,
    pub those: Those,
}

impl Test {
    pub fn foo(&self) -> Option<Those> {
        Some(Those(3))
    }
}

impl Test2 {
    pub fn bar(&mut self) {
        let mut test_writer = self.test.write().unwrap();

        match test_writer.foo() {
            Some(thing) => {
                // call a method add directly on your type to get around the borrow checker
                self.those.add(thing.get());
            },
            None => {}
        }
    }
}

Answer 2

你要么需要结束对self的一部分的借用，然后再改变self

pub fn bar1(&mut self) {
    let foo = self.test.write().unwrap().foo();
    match foo {
        Some(thing) => {
            self.add(thing);
        },
        None => {}
    }
}

或直接变异self的非借用部分

pub fn bar2(&mut self) {
    let test_writer = self.test.write().unwrap();

    match test_writer.foo() {
        Some(thing) => {
            self.those += thing;
        },
        None => {}
    }
}