Rust E0382 — use of moved value

What causes this error

Rust's ownership model: every value has exactly one owner. When you assign a value to a new variable or pass it to a function, ownership is transferred (moved) — the original binding is no longer valid. Types that implement the `Copy` trait (all primitive integers, floats, booleans, char, tuples/arrays of Copy types) copy automatically and don't trigger this error. Types that manage heap memory (`String`, `Vec<T>`, `Box<T>`) are not Copy and are moved instead.

How to fix it

1. 01

   step 1

   Pass a reference instead of moving the value

   If the function only needs to read the value (not own it), change the parameter from `T` to `&T`. This borrows the value without moving it.

   // Takes ownership — caller loses the value
   fn print_name(name: String) {
       println!("{}", name);
   }
   
   let name = String::from("Alice");
   print_name(name);           // name moved here
   println!("{}", name);       // ERROR: use of moved value
   
   // Fix — borrow with &str or &String
   fn print_name(name: &str) {
       println!("{}", name);
   }
   
   let name = String::from("Alice");
   print_name(&name);          // borrow
   println!("{}", name);       // OK

   Copy
2. 02

   step 2

   Clone when you need both the original and a copy

   `clone()` creates a deep copy of heap-allocated data. Use it when you genuinely need two independent copies of the data.

   let original = vec![1, 2, 3];
   let copy = original.clone();   // explicit deep copy
   process(original);             // original is moved here
   println!("{:?}", copy);        // copy is still valid

   Copy
3. 03

   step 3

   Use Copy types when possible

   If your custom type contains only Copy fields and doesn't manage heap memory, derive Copy so it copies automatically like integers do.

   // Without Copy — moved on assignment
   struct Point { x: f64, y: f64 }
   let p1 = Point { x: 1.0, y: 2.0 };
   let p2 = p1;    // p1 moved
   println!("{}", p1.x);  // ERROR
   
   // With Copy + Clone — copied on assignment
   #[derive(Copy, Clone)]
   struct Point { x: f64, y: f64 }
   let p1 = Point { x: 1.0, y: 2.0 };
   let p2 = p1;    // p1 is copied, not moved
   println!("{}", p1.x);  // OK

   Copy
4. 04

   step 4

   Fix move in closures — use move keyword or clone before capture

   Closures capture variables from the environment. If a closure moves a value and you use the variable afterward, it's an E0382. Use `move` explicitly and clone the value before the closure if needed.

   let name = String::from("Alice");
   let greet = move || println!("Hello, {}", name);  // name moved into closure
   println!("{}", name);  // ERROR: use of moved value
   
   // Fix — clone before the move closure
   let name = String::from("Alice");
   let name_clone = name.clone();
   let greet = move || println!("Hello, {}", name_clone);  // clone moved
   println!("{}", name);  // OK — original still valid

   Copy

How to verify the fix

• `cargo build` passes without E0382 errors.
• No unnecessary `.clone()` calls on Copy types (the compiler warns via clippy).
• `cargo clippy` shows no clone-on-copy warnings.