为什么调用`fn pop(&mut self) - > Result <T,&str>`继续借用我的数据结构？

Question

我正在开发一些基本的数据结构来学习语法和Rust.这是我为堆栈提出的:

#[allow(dead_code)]
mod stack {
    pub struct Stack<T> {
        data: Vec<T>,
    }

    impl<T> Stack<T> {
        pub fn new() -> Stack<T> {
            return Stack { data: Vec::new() };
        }

        pub fn pop(&mut self) -> Result<T, &str> {
            let len: usize = self.data.len();

            if len > 0 {
                let idx_to_rmv: usize = len - 1;
                let last: T = self.data.remove(idx_to_rmv);
                return Result::Ok(last);
            } else {
                return Result::Err("Empty stack");
            }
        }

        pub fn push(&mut self, elem: T) {
            self.data.push(elem);
        }

        pub fn is_empty(&self) -> bool {
            return self.data.len() == 0;
        }
    }
}

mod stack_tests {
    use super::stack::Stack;

    #[test]
    fn basics() {
        let mut s: Stack<i16> = Stack::new();

        s.push(16);
        s.push(27);

        let pop_result = s.pop().expect("");

        assert_eq!(s.pop().expect("Empty stack"), 27);
        assert_eq!(s.pop().expect("Empty stack"), 16);

        let pop_empty_result = s.pop();

        match pop_empty_result {
            Ok(_) => panic!("Should have had no result"),
            Err(_) => {
                println!("Empty stack");
            }
        }

        if s.is_empty() {
            println!("O");
        }
    }
}

我得到了这个有趣的错误:

error[E0502]: cannot borrow `s` as immutable because it is also borrowed as mutable
  --> src/main.rs:58:12
   |
49 |         let pop_empty_result = s.pop();
   |                                - mutable borrow occurs here
...
58 |         if s.is_empty() {
   |            ^ immutable borrow occurs here
...
61 |     }
   |     - mutable borrow ends here

为什么我不能只调用pop我的可变结构？

为何pop借用价值？如果我.expect()在它之后添加一个,它没关系,它不会触发该错误.我知道这is_empty需要一个不可变的引用,如果我将其切换为可变,我只需要获得第二个可变借位.

Answer 1

您的pop函数声明为:

pub fn pop(&mut self) -> Result<T, &str>

由于寿命的延长,这扩展到了

pub fn pop<'a>(&'a mut self) -> Result<T, &'a str>

这表示Result::Err变体是一个字符串,只要您调用它的堆栈就存在.由于输入和输出的生命周期是相同的,返回的值可能指向Stack数据结构的某处,因此返回的值必须继续保持借位.

如果我.expect()在它之后添加一个,它没关系,它不会触发该错误.

那是因为expect消耗了它Result,丢弃了Err变体而没有把它变成变量绑定.由于从未存储过,因此无法在任何地方保存借用并将其释放.

要解决此问题,您需要在输入引用和输出引用之间具有不同的生命周期.由于您使用的是字符串文字,因此最简单的解决方案是使用'static生命周期表示:

pub fn pop(&mut self) -> Result<T, &'static str>

额外说明:

• 不要return在块/方法的末尾显式调用:return Result::Ok(last)=> Result::Ok(last).
• Result,, Result::Ok和Result::Err都是通过前奏导入的,所以你不需要对它们进行限定:Result::Ok(last)=> Ok(last).
• 在许多情况下不需要指定类型let len: usize = self.data.len()=> let len = self.data.len().