When writing system-level code or complex data structures like trees and graphs in Rust, one challenge quickly becomes apparent:


how do you share and mutate data across many parts of a program without sacrificing memory safety?

Rust’s ownership system doesn’t allow multiple &mut references or shared ownership by default.


But the standard library offers powerful tools to overcome this — while maintaining safety guarantees.

In this post, we explore some of Rust’s most important tools for working with shared, recursive, and mutable data structures:

• Box<T>


• 
  Rc<T> / Arc<T>
  


• 
  RefCell<T> / Mutex<T>
  


• Weak<T>

We use a tree structure as our running example and discuss real-world system programming, GUIs, and interpreters.

📆 Box: Owning Recursive Types

struct TreeNode {

    value: i32,

    left: Option<Box<TreeNode>>,

    right: Option<Box<TreeNode>>,

}

🔍 Why Use Box?

• Enables recursive types by storing nodes on the heap


• Only allows single ownership (no sharing)

✅ When to Use:

• Heap allocation for simple trees, linked lists


• No need for shared or mutable access


• 
  Example: Binary tree leaves in a compiler, simple DOM nodes in a web renderer

♻️ Rc and RefCell: Shared & Mutable Trees

use std::rc::Rc;

use std::cell::RefCell;



type NodeRef = Rc<RefCell<Node>>;



struct Node {

    value: i32,

    children: Vec<NodeRef>,

}



impl Node {

    fn new(value: i32) -> NodeRef {

        Rc::new(RefCell::new(Node { value, children: vec![] }))

    }

}

🔍 Why Combine Rc + RefCell?

• 
  Rc<T> enables shared ownership
  


• 
  RefCell<T> enables interior mutability, allowing mutation even through &self
  

✅ When to Use:

• Build tree or graph structures


• Allow many owners to read and mutate data


• 
  Example: GUI widget trees (druid, iced), ASTs for interpreters

⚠️ Memory Leaks Warning

Rc uses reference counting — but cannot detect cycles!


If two Rcs reference each other, they’ll leak memory.

🧰 Weak: Breaking Cycles Safely

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

use std::cell::RefCell;



struct Node {

    parent: RefCell<Weak<Node>>,

    children: RefCell<Vec<Rc<Node>>>,

}

🔍 Why Use Weak?

• 
  Weak<T> is a non-owning reference


• Does not increase the strong reference count


• Prevents cyclic leaks between parent and child nodes

✅ When to Use:

• Parent pointers in trees


• Bidirectional linked structures


• 
  Example: Filesystem directory trees, scene graphs

🔐 Mutex and Arc: Thread-Safe Shared State

When moving to multithreading, Rc and RefCell aren't enough.


Instead, use:

use std::sync::{Arc, Mutex};



let data = Arc::new(Mutex::new(vec![1, 2, 3]));



let cloned = data.clone();

std::thread::spawn(move || {

    let mut locked = cloned.lock().unwrap();

    locked.push(4);

});

🔍 Why Use Arc + Mutex?

• 
  Arc<T> = atomic reference counted smart pointer (safe across threads)


• 
  Mutex<T> = exclusive mutable access with runtime locking

✅ When to Use:

• Share state between threads


• Build concurrent task queues, database caches


• 
  Example: Shared blockchain ledger across network threads

✅ Summary: Choose the Right Tool

🧐 Final Thoughts

Understanding Box, Rc, RefCell, Arc, Mutex, and Weak is essential if you want to write serious system-level Rust.

These tools aren't "cheating" Rust’s rules — they are specialized, powerful, safe ways to express complicated relationships (ownership, sharing, mutation, concurrency) while keeping the Rust safety guarantees.

With these patterns, you can build:

• Blockchain nodes


• Compilers


• Embedded device controllers


• Multithreaded servers


• Real-time operating systems (RTOS)

Master these — and you master Rust system programming.