Rust 为什么调用'fn pop（&；mut self）->；结果<；T、 &；str>；`继续借用我的数据结构？

我正在开发一些基本的数据结构来学习语法和一般的语法。下面是我为一个堆栈提出的建议：

#[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");
        }
    }
}

为什么我不能在我的可变结构上调用

pop

为什么

pop

借用该值？如果我在它后面添加一个

.expect（）

，就可以了，它不会触发那个错误。我知道

是空的

接受一个不可变的引用，如果我把它切换到mutable，我只会得到第二个mutable借用。

这是因为。当您构造一个引用的方法时，编译器会检测到，如果没有指定生存期，它会“生成”它们：

---

您的

pop

函数声明为：

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

---

附加说明：

• 不要在块/方法的末尾显式调用

  return

  ：

  returnresult:：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（）

---

添加退货是否会改变什么？我这样做是出于个人喜好，也为了输入变量，所以我现在知道我是否正确理解返回类型。@SamuelYvon不，我的建议没有改变任何东西。您可以做任何您想做的事情，但强烈建议您遵守所使用语言的编码约定。写防锈代码像其他防锈代码一样，JS代码像其他JS代码一样，Go代码像其他Go代码一样，Ruby代码像其他Ruby代码一样，等等。我完全同意！

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

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

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

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