锈盒和移动

Question

I have the following code:

use std::{borrow::BorrowMut, mem};

struct Node {
    ele: i32,
    next: List,
}

enum List {
    Empty,
    More(Box<Node>),
}

pub struct LinkedList {
    head: List,
}

impl LinkedList {
    pub fn new() -> Self {
        LinkedList { head: List::Empty }
    }

    pub fn push(&mut self, value: i32) {
        let new_node = Box::new(Node {
            ele: value,
            next: mem::replace(self.head.borrow_mut(), List::Empty),
        });

        self.head = List::More(new_node);
    }

    pub fn pop(&mut self) -> Option<i32> {
        match mem::replace(self.head.borrow_mut(), List::Empty) {
            List::Empty => None,
            List::More(node) => { // node have type Box<Node>
                self.head = node.next;
                Some(node.ele)
            }
        }
    }
}

But when I change List::More(node) => { to List::More(ref node) => { , will produce the error:

error[E0507]: cannot move out of `node.next` which is behind a shared reference
  --> src/first.rs:35:29
   |
35 |                 self.head = node.next;
   |                             ^^^^^^^^^ move occurs because `node.next` has type `List`, which does not implement the `Copy` trait

It seems that the move occurs in line 35. My questions are:

• Does a move occurred before I changed?
• Why it works before I changed?

In fact, I'm reading "Learn Rust by writing Entirely Too Many Linked Lists" . I noticed that in this commit , the committer changed something to updating to rust 2018. These changes seem to related to my question.

Answer 1

self.head is of type List , as declared in struct List { ... } . Therefore, an owned List must be assigned to self.head . &List and &mut List are not owned, but references. So when assigning to self.head , you must have ownership of the value you want to assign. If you change the match arm to List::More(ref node) => { , node is of type &List , which is a reference and not an owned value and therefore not assignable to self.head .