在match表达式中借用可变的self的Rust实现

Question

在match表达式中借用可变的self的Rust实现

4

我在 match 表达式中使用 self 时遇到了问题:

fn add_once(&'t mut self, p_name: &'t str) -> Box<Element> {
    match self.get(p_name) {
        Some(x) => Box::new(*x),
        None => self.add(p_name),
    }
}

get() 和 add() 函数的签名如下：

fn get(&self, p_name: &str) -> Option<&Element>
fn add(&'t mut self, p_name: &'t str) -> Box<Element>

编译器拒绝了这段代码：

error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
  --> src/main.rs:38:21
   |
36 |         match self.get(p_name) {
   |               ---- immutable borrow occurs here
37 |             Some(x) => Box::new(*x),
38 |             None => self.add(p_name),
   |                     ^^^^ mutable borrow occurs here
39 |         }
40 |     }
   |     - immutable borrow ends here

我理解，但我不知道如何重写match表达式。

在相关问题中，通过让match返回一个值并调用函数来解决了这个问题。然而，在这里不起作用，因为条件语句的含义不是选择一个值而是有选择地执行一个操作。

下面是完整的代码示例：

struct Element<'e> {
    name: &'e str, 
}

impl<'e> Element<'e> {
    fn new(p_name: &str) -> Element {
        Element { name: p_name }
    }
}

struct Top<'t> {
    list: Vec<Element<'t>>,
}

impl<'t> Top<'t> {
    fn new() -> Top<'t> {
        Top { list: vec![] }
    }

    fn get(&self, p_name: &str) -> Option<&Element> {
        for element in self.list.iter() {
            if element.name == p_name {
                return Some(element);
            }
        }
        None
    }

    fn add(&'t mut self, p_name: &'t str) -> Box<Element> {
        let new_element = Box::new(Element::new(p_name));
        self.list.push(*new_element);
        return new_element;
    }

    fn add_once(&'t mut self, p_name: &'t str) -> Box<Element> {
        match self.get(p_name) {
            Some(x) => Box::new(*x),
            None => self.add(p_name),
        }
    }
}

fn main() {
    let mut t = Top::new();
    let plop1 = t.add_once("plop1");
    let plop2 = t.add_once("plop1");
}

- Tifauv'

即使没有可变错误，您仍然会遇到类型统一问题。match的两个分支应该返回相同的类型。同样，我很惊讶add编译通过，因为您首先将内容推入向量，然后再返回；但是在我的看法中，将内容推入向量应该使盒子的内容无效（移动）... add不应该返回&Element，而add_once的结果应该是&Element吗？ - Matthieu M.

@MatthieuM.，它能够工作是因为Element是Copy，所以*new_element返回元素的副本。 - Vladimir Matveev

@VladimirMatveev：啊，是的，我忘记了Copy还没有选择加入。不过，对我来说，这似乎表明了一个设计缺陷：Top看起来应该是通用的，并且适用于非Copy类型。 - Matthieu M.

我对Rust非常陌生，所以可能存在设计错误。Top确实应该适用于非“Copy”类型。 - Tifauv'

@MatthieuM。最初，我想让add和add_once返回&Element，但无法使其正常工作。 - Tifauv'

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Matthieu M. · Accepted Answer

首先，让我们解决设计问题。主要问题是生命周期混淆：

struct Top<'t> {
    list: Vec<Element<'t>>,
}

impl<'t> Top<'t> {
    fn add(&'t mut self, p_name: &'t str) -> Box<Element>;
    fn add_once(&'t mut self, p_name: &'t str) -> Box<Element>;
}

你认为self应该至少与包含它的引用的生存期't相同。但实际上，你需要的是 self 活得比't更短，这样任何&'t都能够在self消失之前继续存在。

如果我们进行改变，就可以轻松地返回对Element的引用：

impl<'t> Top<'t> {
    fn add<'a>(&'a mut self, p_name: &'t str) -> &'a Element<'t>;
    fn add_once<'a>(&'a mut self, p_name: &'t str) -> &'a Element<'t>;
}

请注意，对于 Element 的引用的生命周期 'a 与其包含的引用的生命周期 't 不同（实际上要更短）。

解决了这个问题之后，这些函数应该就可以正常工作了。

fn position(&self, p_name: &str) -> Option<usize> {
    self.list.iter().position(|e| e.name == p_name)
}

fn add<'a>(&'a mut self, p_name: &'t str) -> &'a Element<'t> {
    self.list.push(Element::new(p_name));
    &self.list[self.list.len() - 1]
}

fn add_once<'a>(&'a mut self, p_name: &'t str) -> &'a Element<'t> {
    if let Some(p) = self.position(p_name) {
        return &self.list[p];
    }
    self.add(p_name)
}

position可以被重复使用来进行get操作：

fn get<'a>(&'a self, p_name: &str) -> Option<&'a Element<'t>> {
    self.position(p_name).map(|pos| &self.list[pos])
}

在理想情况下，我期望以下内容能够正常工作：

fn add_once<'a>(&'a mut self, p_name: &'t str) -> &'a Element<'t> {
    match self.get(p_name) {
        Some(x) => x,
        None => self.add(p_name)
    }
}

然而，我记得有一个讨论，认为借用检查器不够宽松：由self.get引起的借用范围被计算为整个match表达式，即使在None分支中，临时变量也无法访问。

一旦Rust中纳入了“非词法生命周期”，就应该解决这个问题，这是正在进行中的工作。