rust-mutability

Interior mutability expert covering Cell, RefCell, Mutex, RwLock patterns, borrow conflicts (E0596, E0499, E0502), and thread-safe mutation strategies.

Jump to install

Repository: huiali/rust-skills
Last source activity: February 9, 2026 at 07:17
Detected SKILL.md language: English
Stars: 44
Forks: 7

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

A direct command skips the review prompt. Inspect the source before running it.

npx skills add https://github.com/huiali/rust-skills --skill rust-mutability

The command stays on one line. Scroll horizontally to inspect it before copying.

Prefer a local copy? Download the files currently available to SkillsMP.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

File Explorer

4 files

SKILL.md

Source instructions · Read-only preview

Back to search Back to installation

rust-actor

Actor model expert covering message passing, state isolation, supervision trees, deadlock prevention, fault tolerance, Actix framework, and Erlang-style concurrency patterns.

2026-02-09

rust-anti-pattern

Rust anti-patterns and common mistakes expert. Handles code review issues with clone abuse, unwrap in production, String misuse, index loops, and refactoring guidance.

2026-02-09

rust-async-pattern

Advanced async patterns expert covering Stream implementation, zero-copy buffers, tokio::spawn lifetimes, plugin system scheduling, tonic streaming, and async lifetime management.

2026-02-09

View all from this repository

use std::cell::Cell;

struct State {
    count: Cell<u32>,
}

impl State {
    // Get immutable &self, mutate interior
    fn increment(&self) {
        self.count.set(self.count.get() + 1);
    }
}

use std::cell::RefCell;

struct Cache {
    data: RefCell<HashMap<String, Value>>,
}

impl Cache {
    fn insert(&self, key: String, value: Value) {
        self.data.borrow_mut().insert(key, value);
    }

    fn get(&self, key: &str) -> Option<Value> {
        self.data.borrow().get(key).cloned()
    }
}

use std::sync::Mutex;

struct SharedState {
    data: Mutex<HashMap<String, Value>>,
}

impl SharedState {
    fn insert(&self, key: String, value: Value) {
        self.data.lock().unwrap().insert(key, value);
    }
}

use std::sync::RwLock;

struct Config {
    settings: RwLock<HashMap<String, String>>,
}

impl Config {
    fn get(&self, key: &str) -> Option<String> {
        self.settings.read().unwrap().get(key).cloned()
    }

    fn update(&self, key: String, value: String) {
        self.settings.write().unwrap().insert(key, value);
    }
}

At any time, you can have either:
├─ Multiple &T (immutable borrows)
└─ OR one &mut T (mutable borrow)

Never both simultaneously

Code	Meaning	Don't Say	Ask Instead
E0596	Cannot get mutable reference	"add mut"	Does this really need mutability?
E0499	Multiple mutable borrows conflict	"split borrows"	Is data structure design correct?
E0502	Borrow conflict	"separate scopes"	Why both borrows needed simultaneously?
RefCell panic	Runtime borrow error	"use try_borrow"	Is runtime checking appropriate?

Single-threaded?
  Need &mut from &self?
    → RefCell<T>
  Copy type?
    → Cell<T>
  Otherwise?
    → &mut T

Multi-threaded?
  Simple atomic?
    → AtomicU64/AtomicBool
  Complex data?
    Read-heavy → RwLock<T>
    Write-heavy → Mutex<T>

E0499 (multiple mut borrows)?
  → Split struct into smaller pieces
  → Use Cell/RefCell for interior mutability
  → Redesign to avoid simultaneous access

E0502 (borrow conflict)?
  → Minimize borrow scopes
  → Clone data if needed
  → Restructure code flow

RefCell?
  ✅ Flexible
  ❌ Runtime panics possible
  → Use in prototypes, single-threaded

Mutex?
  ✅ Thread-safe
  ❌ Lock contention
  → Profile before optimizing

RwLock?
  ✅ Many readers efficient
  ❌ Writer starvation possible
  → Use when reads >> writes

use std::sync::atomic::{AtomicU64, Ordering};

let counter = AtomicU64::new(0);
counter.fetch_add(1, Ordering::Relaxed);

use std::sync::Mutex;

let data = Mutex::new(HashMap::new());
data.lock().unwrap().insert(key, value);

use std::sync::RwLock;

let data = RwLock::new(HashMap::new());
data.read().unwrap().get(&key);  // Many readers
data.write().unwrap().insert(key, value);  // Few writers

// ❌ Bad: multiple mutable borrows
let r1 = &mut data.field1;
let r2 = &mut data.field2;  // Error!

// ✅ Good: split borrows
let (field1, field2) = (&mut data.field1, &mut data.field2);

// ✅ Better: restructure
struct Data {
    part1: Part1,
    part2: Part2,
}

// ❌ Bad: nested borrows
let cell = RefCell::new(vec![1, 2, 3]);
let borrow1 = cell.borrow();
let borrow2 = cell.borrow_mut();  // Panics!

// ✅ Good: drop first borrow
{
    let borrow1 = cell.borrow();
    // use borrow1...
}  // dropped
let borrow2 = cell.borrow_mut();  // OK

// ✅ Better: use try_borrow
if let Ok(mut b) = cell.try_borrow_mut() {
    // safe mutation
}

// ❌ Bad: MutexGuard across await
let guard = mutex.lock().unwrap();
async_op().await;  // DANGER

// ✅ Good: drop lock before await
let value = {
    let guard = mutex.lock().unwrap();
    guard.clone()
};  // lock dropped
async_op().await;

# Check compilation
cargo check

# Look for borrow conflict errors
cargo check 2>&1 | grep -E "E0499|E0502|E0596"

# Run tests
cargo test

# Check for deadlocks (with loom)
cargo test --features loom

# Clippy warnings
cargo clippy -- -W clippy::mutex_atomic

// ✅ Split struct to enable simultaneous borrows
struct Data {
    readers: Vec<Reader>,
    writers: Vec<Writer>,
}

fn process(data: &mut Data) {
    let readers = &data.readers;
    let writers = &mut data.writers;  // OK, different fields
    // use both...
}

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

#[derive(Clone)]
struct Shared {
    inner: Arc<Mutex<Inner>>,
}

impl Shared {
    fn update(&self) {
        self.inner.lock().unwrap().modify();
    }
}

name	rust-mutability
description	Interior mutability expert covering Cell, RefCell, Mutex, RwLock patterns, borrow conflicts (E0596, E0499, E0502), and thread-safe mutation strategies.
metadata	{"triggers":["mutability","mut","Cell","RefCell","Mutex","RwLock","interior mutability","borrow conflict","E0596","E0499","E0502"]}

Type	Controller	Thread-Safe	Use Case
`&mut T`	External caller	Yes	Standard mutable borrow
`Cell<T>`	Interior	No	Copy types with interior mutability
`RefCell<T>`	Interior	No	Non-Copy types with interior mutability
`Mutex<T>`	Interior	Yes	Multi-threaded interior mutability
`RwLock<T>`	Interior	Yes	Multi-threaded read-write lock

name	rust-mutability
description	Interior mutability expert covering Cell, RefCell, Mutex, RwLock patterns, borrow conflicts (E0596, E0499, E0502), and thread-safe mutation strategies.
metadata	{"triggers":["mutability","mut","Cell","RefCell","Mutex","RwLock","interior mutability","borrow conflict","E0596","E0499","E0502"]}

Type	Controller	Thread-Safe	Use Case
`&mut T`	External caller	Yes	Standard mutable borrow
`Cell<T>`	Interior	No	Copy types with interior mutability
`RefCell<T>`	Interior	No	Non-Copy types with interior mutability
`Mutex<T>`	Interior	Yes	Multi-threaded interior mutability
`RwLock<T>`	Interior	Yes	Multi-threaded read-write lock

rust-mutability

Install options

Review the source files

Mutability Types

Solution Patterns

Pattern 1: External Mutability

Mutability Types

Solution Patterns

Pattern 1: External Mutability

Pattern 2: Cell for Copy Types

Pattern 3: RefCell for Non-Copy Types

Pattern 4: Mutex for Thread Safety

Pattern 5: RwLock for Read-Heavy Workloads

Borrow Rules

Error Code Quick Reference

Workflow

Step 1: Choose Mutability Strategy

Step 2: Handle Borrow Conflicts

Step 3: Consider Trade-offs

Thread-Safe Selection

Atomic Types

Mutex

RwLock

Common Pitfalls

1. Borrow Conflict

2. RefCell Panic

3. Lock Held Across Await

Review Checklist

Verification Commands

Advanced Patterns

Splitting Borrows

Interior Mutability with Shared Ownership

Related Skills

Localized Reference

rust-mutability

Source facts

Install options

Review the source files

More from this repository

Mutability Types

Solution Patterns

Pattern 1: External Mutability

Mutability Types

Solution Patterns

Pattern 1: External Mutability

Pattern 2: Cell for Copy Types

Pattern 3: RefCell for Non-Copy Types

Pattern 4: Mutex for Thread Safety

Pattern 5: RwLock for Read-Heavy Workloads

Borrow Rules

Error Code Quick Reference

Workflow

Step 1: Choose Mutability Strategy

Step 2: Handle Borrow Conflicts

Step 3: Consider Trade-offs

Thread-Safe Selection

Atomic Types

Mutex

RwLock

Common Pitfalls

1. Borrow Conflict

2. RefCell Panic

3. Lock Held Across Await

Review Checklist

Verification Commands

Advanced Patterns

Splitting Borrows

Interior Mutability with Shared Ownership

Related Skills

Localized Reference

More from this repository