How to Use Weak<T> to Prevent Reference Cycles

Use Weak<T> for back-references (like a child pointing to a parent) to break reference cycles that prevent Rc<T> from dropping. Define the back-reference field as RefCell<Weak<Node>> and use Rc::downgrade to create the weak pointer from the strong Rc.

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
}

A reference cycle happens when two objects hold strong references to each other, preventing them from ever being deleted. Using Weak<T> breaks this cycle by creating a non-owning link that doesn't count toward the object's lifetime. Think of it like a child pointing to a parent: the parent owns the child, but the child only has a weak pointer back to the parent so the parent can still be removed if needed.