1 不正确的实现```rust

pub fn peek(&self) -> Option<&T> { self.head.map(|node| { &node.elem }) }

  2.    - `Option<T>`的`map`方法第一个参数为`self`，要求获取所有权，这是不允许的：不能通过共享引用`&self`取得`self.head`的所有权（不能移动`self.head`）
  3.    - 在作为`map`参数的闭包中，`node`是所有权类型，从闭包中返回所有权类型的引用是不允许的！
  4. <a name="MFakj"></a>
  5. # 2 使用Option::as_ref()```rust
  6. impl<T> Option<T> {
  7.     pub fn as_ref(&self) -> Option<&T>;// Option<&Box<Node<T>>
  8. }
  10. pub fn peek(&self) -> Option<&T> {
  11.     self.head.as_ref().map(|node| {// node 的类型是 &Box<Node<T>>
  12.         &node.elem
  13.     })
  14. }

3 使用Option::as_mut()```rust

impl Option { pub fn as_mut(&mut self) -> Option<&mut T>;// Option<&mut Box> }

pub fn peek_mut(&mut self) -> Option<&mut T> { self.head.as_mut().map(|node| { &mut node.elem }) }

  2. <a name="D2jHu"></a>
  3. # 4 测试```rust
  4. #[test]
  5. fn peek() {
  6.     let mut list = List::new();
  7.     assert_eq!(list.peek(), None);
  8.     assert_eq!(list.peek_mut(), None);
  9.     list.push(1);
  10.     list.push(2);
  11.     list.push(3);
  13.     assert_eq!(list.peek(), Some(&3));
  14.     assert_eq!(list.peek_mut(), Some(&mut 3));
  15.     list.peek_mut().map(|value| *value = 42);
  17.     assert_eq!(list.peek(), Some(&42));
  18.     assert_eq!(list.pop(), Some(42));
  19. }

注意这一句：list.peek_mut().map(|value| *value = 42);，不能写成list.peek_mut().map(|&mut value| value = 42);

  • peek_mut()返回类型是Option<&mut i32>，则
    • 写成|&mut value|时，value对应i32（因为前面的&mut已经匹配了），是一个不可变变量
    • 写成|value|时，value对应&mut i32，是一个可变引用