Use of take in drop function of persisted list - data-structures

Question

I am reading Learning Rust With Entirely Too Many Linked Lists, specifically the chapter about a persistent singly-linked stack.
I am having difficulty understanding use of take in the drop function.
Without it, I get the same logs in drop.
use std::rc::Rc;
use std::fmt;
type Link<T> = Option<Rc<Node<T>>>;
#[derive(Debug)]
pub struct List<T>
where
T: fmt::Debug,
{
head: Link<T>,
}
#[derive(Debug)]
struct Node<T>
where
T: fmt::Debug,
{
val: T,
next: Link<T>,
}
impl<T> List<T>
where
T: fmt::Debug,
{
pub fn new() -> Self {
List { head: None }
}
pub fn append(&self, val: T) -> List<T> {
List {
head: Some(Rc::new(Node {
val: val,
next: self.head.clone(),
})),
}
}
}
impl<T> Drop for List<T>
where
T: fmt::Debug,
{
fn drop(&mut self) {
println!("1 : {:?}", self);
let mut curr_list = self.head.take();
println!("2");
while let Some(node) = curr_list {
println!("3");
match Rc::try_unwrap(node) {
Err(_) => {
println!("4");
break;
}
Ok(ref mut x) => {
println!("5");
curr_list = x.next.take()
}
}
println!("6");
}
println!("7");
}
}
fn main() {
let list = List::new().append(1).append(2);
let _list2 = list.append(3);
let _list3 = list.append(3);
let _list4 = list.append(3);
let _list5 = list.append(3);
}
Playground
It outputs:
1 : List { head: Some(Node { val: 1, next: None }) }
2
3
4 : stopping at 1
7
1 : List { head: None }
2
7
1 : List { head: Some(Node { val: 3, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }) }
2
3
5: dropping 3
6
3
4 : stopping at 2
7
1 : List { head: Some(Node { val: 3, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }) }
2
3
5: dropping 3
6
3
4 : stopping at 2
7
1 : List { head: Some(Node { val: 3, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }) }
2
3
5: dropping 3
6
3
4 : stopping at 2
7
1 : List { head: Some(Node { val: 3, next: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }) }
2
3
5: dropping 3
6
3
4 : stopping at 2
7
1 : List { head: Some(Node { val: 2, next: Some(Node { val: 1, next: None }) }) }
2
3
5: dropping 2
6
3
5: dropping 1
6
7
The first and second 1 : List { is because of first line in main, which is destroying temp lists created. The next 3 1 : List { are lists getting dropped in reverse order of creation. Finally the shared list of size 2 is dropped.
Even if I remove take from line : curr_list = x.next.take() and remove ref mut for x in fn drop I still get the same output.
What is x there and why does take() have no effects?
I earlier thought that take would change the original list by setting the next to None, but that is not possible as that will invalidate the list for other people who have references.
Implementing drop on Node :
impl<T> Drop for Node<T> where T: fmt::Debug {
fn drop(&mut self) {
println!("Node drop : {:?}", self.val);
}
}
so, Just after Ok(ref mut x) block, Node x is dropped.