Reassign to a higher-scoped mutable referenced variable within a loop - rust

Question

So I'm trying to implement a linked list in Rust to better understand the language and the following is what I came up with.
use std::rc::Rc;
use std::fmt::Debug;
struct Node<T>
where
T: Debug,
{
value: T,
next: Option<Rc<Box<Node<T>>>>,
}
pub struct LinkedList<T>
where
T: Debug,
{
start: Option<Rc<Box<Node<T>>>>,
end: Option<Rc<Box<Node<T>>>>,
}
I managed to implement the insert method, but I'm having trouble implementing the traverse method.
impl<T> LinkedList<T>
where
T: Debug,
{
pub fn insert(&mut self, value: T) {
let node = Rc::new(Box::new(Node { value, next: None }));
match &mut self.end {
None => {
self.start = Some(Rc::clone(&node));
}
Some(ref mut end_node) => {
if let Some(mutable_node) = Rc::get_mut(end_node) {
mutable_node.next = Some(Rc::clone(&node));
}
}
}
self.end = Some(node);
}
pub fn traverse(&mut self) {
let mut ptr = &mut self.start;
while let Some(ref mut node_rc) = &mut ptr {
let inner_ptr = Rc::get_mut(node_rc).unwrap();
*ptr = inner_ptr.next;
}
}
}
In the traverse method I'm trying to do the basic, initialize a pointer at start and keep moving the pointer forward at each iteration of the loop, but the above traverse implementation gives me the following error
rustc: cannot move out of `inner_ptr.next` which is behind a mutable reference
move occurs because `inner_ptr.next` has type `Option<Rc<Box<Node<T>>>>`, which does not implement the `Copy` trait
which made some sense to me, so I tried modifying my code to
ptr = &mut inner_ptr.next;
but now I get a different error stating
|
56 | while let Some(ref mut node_rc) = &mut ptr {
| -------- borrow of `ptr` occurs here
...
59 | ptr = &mut inner_ptr.next;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| assignment to borrowed `ptr` occurs here
| borrow later used here
I thought I was getting this error because inner_ptr is dropped at the end of each loop iteration, so I made the following change to the traverse method by having inner_ptr's lifetime to equal ptr's lifetime, like so
pub fn traverse(&mut self) {
let mut ptr = &mut self.start;
let mut inner_ptr: &mut Box<Node<T>>;
while let Some(ref mut node_rc) = &mut ptr {
inner_ptr = Rc::get_mut(node_rc).unwrap();
ptr = &mut inner_ptr.next;
}
}
But, the compiler throws the same error in this case as well. Clearly I'm missing something fundamental here about Rust's borrow mechanism, but I can't figure out what

Answer 1

You're taking a mutable reference of ptr when you should't.
pub fn traverse(&mut self) {
let mut ptr = &mut self.start;
while let Some(ref mut node_rc) = ptr { // don't take a mutable reference here
println!("{:?}", node_rc.value);
let inner_ptr = Rc::get_mut(node_rc).unwrap();
ptr = &mut inner_ptr.next;
}
}
You don't want to take a mutable reference there because you don't want to borrow it which would prevent you from changing it later.
Instead you want to move it and replace it every loop.