Agent skill

m02-resource

CRITICAL: Use for smart pointers and resource management. Triggers: Box, Rc, Arc, Weak, RefCell, Cell, smart pointer, heap allocation, reference counting, RAII, Drop, should I use Box or Rc, when to use Arc vs Rc, 智能指针, 引用计数, 堆分配

View SKILL.md on GitHub Repository
Stars 941
Forks 87

Install this agent skill to your Project

npx add-skill https://github.com/actionbook/rust-skills/tree/main/skills/m02-resource

SKILL.md

Resource Management

Layer 1: Language Mechanics

Core Question

What ownership pattern does this resource need?

Before choosing a smart pointer, understand:

  • Is ownership single or shared?
  • Is access single-threaded or multi-threaded?
  • Are there potential cycles?

Error → Design Question

Error Don't Just Say Ask Instead
"Need heap allocation" "Use Box" Why can't this be on stack?
Rc memory leak "Use Weak" Is the cycle necessary in design?
RefCell panic "Use try_borrow" Is runtime check the right approach?
Arc overhead complaint "Accept it" Is multi-thread access actually needed?

Thinking Prompt

Before choosing a smart pointer:

  1. What's the ownership model?

    • Single owner → Box or owned value
    • Shared ownership → Rc/Arc
    • Weak reference → Weak

  2. What's the thread context?

    • Single-thread → Rc, Cell, RefCell
    • Multi-thread → Arc, Mutex, RwLock

  3. Are there cycles?

    • Yes → One direction must be Weak
    • No → Regular Rc/Arc is fine

Trace Up ↑

When pointer choice is unclear, trace to design:

"Should I use Arc or Rc?"
    ↑ Ask: Is this data shared across threads?
    ↑ Check: m07-concurrency (thread model)
    ↑ Check: domain-* (performance constraints)
Situation Trace To Question
Rc vs Arc confusion m07-concurrency What's the concurrency model?
RefCell panics m03-mutability Is interior mutability right here?
Memory leaks m12-lifecycle Where should cleanup happen?

Trace Down ↓

From design to implementation:

"Need single-owner heap data"
    ↓ Use: Box<T>

"Need shared immutable data (single-thread)"
    ↓ Use: Rc<T>

"Need shared immutable data (multi-thread)"
    ↓ Use: Arc<T>

"Need to break reference cycle"
    ↓ Use: Weak<T>

"Need shared mutable data"
    ↓ Single-thread: Rc<RefCell<T>>
    ↓ Multi-thread: Arc<Mutex<T>> or Arc<RwLock<T>>

Quick Reference

Type Ownership Thread-Safe Use When
Box<T> Single Yes Heap allocation, recursive types
Rc<T> Shared No Single-thread shared ownership
Arc<T> Shared Yes Multi-thread shared ownership
Weak<T> Weak ref Same as Rc/Arc Break reference cycles
Cell<T> Single No Interior mutability (Copy types)
RefCell<T> Single No Interior mutability (runtime check)

Decision Flowchart

Need heap allocation?
├─ Yes → Single owner?
│        ├─ Yes → Box<T>
│        └─ No → Multi-thread?
│                ├─ Yes → Arc<T>
│                └─ No → Rc<T>
└─ No → Stack allocation (default)

Have reference cycles?
├─ Yes → Use Weak for one direction
└─ No → Regular Rc/Arc

Need interior mutability?
├─ Yes → Thread-safe needed?
│        ├─ Yes → Mutex<T> or RwLock<T>
│        └─ No → T: Copy? → Cell<T> : RefCell<T>
└─ No → Use &mut T

Common Errors

Problem Cause Fix
Rc cycle leak Mutual strong refs Use Weak for one direction
RefCell panic Borrow conflict at runtime Use try_borrow or restructure
Arc overhead Atomic ops in hot path Consider Rc if single-threaded
Box unnecessary Data fits on stack Remove Box

Anti-Patterns

Anti-Pattern Why Bad Better
Arc everywhere Unnecessary atomic overhead Use Rc for single-thread
RefCell everywhere Runtime panics Design clear ownership
Box for small types Unnecessary allocation Stack allocation
Ignore Weak for cycles Memory leaks Design parent-child with Weak

Related Skills

When See
Ownership errors m01-ownership
Interior mutability details m03-mutability
Multi-thread context m07-concurrency
Resource lifecycle m12-lifecycle

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

actionbook/rust-skills

meta-cognition-parallel

EXPERIMENTAL: Three-layer parallel meta-cognition analysis. Triggers on: /meta-parallel, 三层分析, parallel analysis, 并行元认知

941 87
Explore
actionbook/rust-skills

domain-cloud-native

Use when building cloud-native apps. Keywords: kubernetes, k8s, docker, container, grpc, tonic, microservice, service mesh, observability, tracing, metrics, health check, cloud, deployment, 云原生, 微服务, 容器

941 87
Explore
actionbook/rust-skills

m07-concurrency

CRITICAL: Use for concurrency/async. Triggers: E0277 Send Sync, cannot be sent between threads, thread, spawn, channel, mpsc, Mutex, RwLock, Atomic, async, await, Future, tokio, deadlock, race condition, 并发, 线程, 异步, 死锁

941 87
Explore
actionbook/rust-skills

unsafe-checker

CRITICAL: Use for unsafe Rust code review and FFI. Triggers on: unsafe, raw pointer, FFI, extern, transmute, *mut, *const, union, #[repr(C)], libc, std::ffi, MaybeUninit, NonNull, SAFETY comment, soundness, undefined behavior, UB, safe wrapper, memory layout, bindgen, cbindgen, CString, CStr, 安全抽象, 裸指针, 外部函数接口, 内存布局, 不安全代码, FFI 绑定, 未定义行为

941 87
Explore
actionbook/rust-skills

rust-refactor-helper

Safe Rust refactoring with LSP analysis. Triggers on: /refactor, rename symbol, move function, extract, 重构, 重命名, 提取函数, 安全重构

941 87
Explore
actionbook/rust-skills

rust-skill-creator

Use when creating skills for Rust crates or std library documentation. Keywords: create rust skill, create crate skill, create std skill, 创建 rust skill, 创建 crate skill, 创建 std skill, 动态 rust skill, 动态 crate skill, skill for tokio, skill for serde, skill for axum, generate rust skill, rust 技能, crate 技能, 从文档创建skill, from docs create skill

941 87
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results