rust-resource_skill

Overview

This skill is an expert layer for Rust smart pointers and resource management. I provide clear decision guidance, common pitfalls and fixes, and performance-minded patterns for Box, Rc, Arc, Weak, RefCell, Cell, RAII and Drop. The goal is to help engineers choose the right pointer, avoid leaks and panics, and design safe, efficient ownership for real-world code.

How this skill works

I inspect ownership requirements (single owner vs shared), threading constraints (single-thread vs multi-thread), and mutability needs to recommend concrete pointer types and synchronization primitives. I detect common anti-patterns such as Rc cycles, RefCell double-borrows, unnecessary Arc usage, and suggest fixes like Weak, try_borrow, or switching to Rc. I also provide RAII/Drop guidance and micro-optimizations (e.g., RwLock vs Mutex, Atomic counters).

When to use it

• Use Box<T> for single-owner heap allocation, recursive types, or trait objects.
• Use Rc<T>/RefCell<T> for single-thread shared data with interior mutability at runtime.
• Use Arc<T>/Arc<Mutex<T>> or Arc<RwLock<T>> for multi-thread shared data, choose locks based on read/write patterns.
• Use Weak<T> to break reference cycles and avoid memory leaks with graph-like structures.
• Use Cell<T> for interior mutability of Copy types and RefCell<T> for non-Copy types.
• Prefer plain values or &T when stack allocation and borrow rules suffice.

Best practices

• Start with the simplest option: plain value, &T, or Box<T> before adding shared pointers.
• Break cycles with Weak to prevent Rc/Arc leaks in parent/child graphs.
• Avoid RefCell panics by preferring try_borrow/_mut and by minimizing overlapping borrows.
• Don’t use Arc in single-thread contexts; prefer Rc to avoid atomic overhead.
• Choose RwLock for read-heavy workloads and Mutex for mostly-writes; use atomics for counters where possible.

Example use cases

• Designing a tree/graph where children reference parents: use Rc for ownership and Weak for parent links.
• Sharing a configuration object across threads: Arc<T> for read-only, Arc<RwLock<T>> for read-mostly updates.
• Implementing a mutable shared cache in one thread: Rc<RefCell<HashMap<...>>> to allow interior mutability.
• Managing OS resources with RAII: implement Drop to ensure file/handle cleanup and use guard patterns for scoped release.
• Optimizing a hotspot: replace Mutex<u64> counters with AtomicU64 or use RwLock for heavy-read scenarios.