Rust borrow checker error — cannot borrow as mutable / moved value

What causes this error

Rust's ownership system enforces memory safety at compile time. The borrow checker rejects code where: (1) a mutable reference exists alongside any other reference to the same data (E0502), (2) a value is used after being moved (E0382), (3) a mutable variable is borrowed immutably while also borrowed mutably (E0596), or (4) two mutable references to the same data exist simultaneously (E0499). These rules prevent data races and dangling pointers.

How to fix it

1. 01

   step 1

   Read the full error message — it tells you where each borrow starts and ends

   Rust's error messages are detailed. They show the exact line of the conflicting borrows. Run `rustc --explain E0502` for a full explanation with examples for your specific error code.

   # Get detailed explanation for a specific error code
   rustc --explain E0502
   rustc --explain E0382  # use of moved value
   rustc --explain E0505  # cannot move out of because it is borrowed
   rustc --explain E0596  # cannot borrow as mutable

   Copy
2. 02

   step 2

   Narrow the scope of borrows — let them end before the conflicting operation

   The borrow checker tracks when borrows start and end. Restructure code so the immutable borrow ends (goes out of scope) before the mutable borrow begins.

   // BAD — immutable borrow of map lives across the insert
   let mut map = HashMap::new();
   map.insert("key", 1);
   let val = map.get("key");  // immutable borrow
   map.insert("other", 2);   // mutable borrow — ERROR
   println!("{:?}", val);
   
   // GOOD — copy the value out before mutating
   let mut map = HashMap::new();
   map.insert("key", 1);
   let val = map.get("key").copied();  // copy the value, end the borrow
   map.insert("other", 2);             // OK — no live borrows
   println!("{:?}", val);

   Copy
3. 03

   step 3

   Use clone() when you need to keep the data after a move

   When a value is moved into a function and you need to use it afterward, `clone()` creates an owned copy. This is a runtime cost — use it when restructuring is impractical.

   // E0382: use of moved value
   fn consume(s: String) { println!("{}", s); }  // takes ownership
   
   let s = String::from("hello");
   consume(s);          // s is moved here
   println!("{}", s);   // ERROR: use of moved value
   
   // Fix A — clone before moving
   let s = String::from("hello");
   consume(s.clone());  // clone is moved, original s still valid
   println!("{}", s);
   
   // Fix B — take a reference instead of ownership
   fn consume(s: &str) { println!("{}", s); }  // borrows instead
   let s = String::from("hello");
   consume(&s);         // borrow, s not moved
   println!("{}", s);

   Copy
4. 04

   step 4

   Use Rc<RefCell<T>> for shared mutable state (single-threaded)

   When the borrow checker structure is genuinely needed at runtime (graph nodes, tree with parent pointers), use `Rc<RefCell<T>>` for shared ownership with runtime-checked mutability. `Arc<Mutex<T>>` for multi-threaded.

   use std::rc::Rc;
   use std::cell::RefCell;
   
   let shared = Rc::new(RefCell::new(vec![1, 2, 3]));
   let clone1 = Rc::clone(&shared);
   let clone2 = Rc::clone(&shared);
   
   clone1.borrow_mut().push(4);  // runtime borrow check
   println!("{:?}", clone2.borrow());  // [1, 2, 3, 4]

   Copy

How to verify the fix

• `cargo build` completes without borrow checker errors.
• No unnecessary `clone()` calls — each clone should have a specific reason.
• `cargo clippy` shows no ownership-related warnings.