Use Weak Rc (non-owning reference) to break the reference cycle.

Author: polyactis

c15_6_ref_cycles/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "c15_6_ref_cycles"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

c15_6_ref_cycles/src/main.rs

@@ -0,0 +1,115 @@
+use crate::List::{Cons, Nil};
+use std::cell::RefCell;
+use std::rc::{Rc, Weak};
+
+#[derive(Debug)]
+enum List {
+    Cons(i32, RefCell<Rc<List>>),
+    Nil,
+}
+
+impl List {
+    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
+        match self {
+            Cons(_, item) => Some(item),
+            Nil => None,
+        }
+    }
+}
+
+
+
+#[derive(Debug)]
+struct Node {
+    value: i32,
+    parent: RefCell<Weak<Node>>,
+    children: RefCell<Vec<Rc<Node>>>,
+}
+
+
+fn main() {
+    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));
+
+    println!("a initial rc count = {}", Rc::strong_count(&a));
+    println!("a next item = {:?}", a.tail());
+
+    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));
+
+    println!("a rc count after b creation = {}", Rc::strong_count(&a));
+    println!("b initial rc count = {}", Rc::strong_count(&b));
+    println!("next item of b = {:?}", b.tail());
+
+    if let Some(link) = a.tail() {
+        *link.borrow_mut() = Rc::clone(&b);
+    }
+    println!("a tail is now changed to be b.");
+
+    println!("b rc count after changing a = {}", Rc::strong_count(&b));
+    println!("a rc count after changing a = {}", Rc::strong_count(&a));
+
+    // Uncomment the next line to see that we have a cycle;
+    // it will overflow the stack
+    //println!("a next item = {:?}", a.tail());
+    /*
+    RefCell { value: Cons(10, RefCell { 
+        ...
+    thread 'main' has overflowed its stack
+    fatal runtime error: stack overflow
+    Aborted (core dumped)
+    */
+
+    let leaf = Rc::new(Node {
+        value: 3,
+        parent: RefCell::new(Weak::new()),
+        children: RefCell::new(vec![]),
+    });
+
+    println!("leaf parent = {:?}, value={}", leaf.parent.borrow().upgrade(),
+        leaf.value);
+
+    println!(
+        "leaf strong = {}, weak = {}",
+        Rc::strong_count(&leaf),
+        Rc::weak_count(&leaf),
+    );
+
+    {
+        let branch = Rc::new(Node {
+            value: 5,
+            parent: RefCell::new(Weak::new()),
+            children: RefCell::new(vec![Rc::clone(&leaf)]),
+        });
+        println!(
+            "branch strong = {}, weak = {}, value={}",
+            Rc::strong_count(&branch),
+            Rc::weak_count(&branch),
+            branch.value,
+        );
+
+        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);
+        println!("parent of leaf is changed to branch.");
+
+        println!(
+            "branch strong = {}, weak = {}",
+            Rc::strong_count(&branch),
+            Rc::weak_count(&branch),
+        );
+
+        println!(
+            "leaf strong = {}, weak = {}",
+            Rc::strong_count(&leaf),
+            Rc::weak_count(&leaf),
+        );
+        println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
+    }
+    println!("branch is out of scope.");
+    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
+    println!(
+        "leaf strong = {}, weak = {}",
+        Rc::strong_count(&leaf),
+        Rc::weak_count(&leaf),
+    );
+
+    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
+
+}