What is the difference between move, copy, and clone semantics in Rust?

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Assign a non-Copy value

   Binding one variable to another (let b = a) moves ownership; using a afterward is a compile error.

2. Step 2

   Assign a Copy value

   For types implementing Copy (integers, bools, char, simple structs of Copy fields), assignment duplicates bitwise and both remain valid.

3. Step 3

   Decide when you need Clone

   If you need an independent copy of a heap-owning type, call .clone() explicitly to deep-copy the owned data.

4. Step 4

   Understand the trait relationship

   Copy requires Clone as a supertrait; Copy is an implicit, cheap duplication while Clone is an explicit, potentially deep one.

5. Step 5

   Watch for moves into functions

   Passing a non-Copy value to a function moves it in; borrow with & instead if you want to keep using it afterward.

Code Example

fn main() {
    // Copy: i32 implements Copy, both stay valid
    let a = 5;
    let b = a;
    println!("{} {}", a, b); // OK

    // Move: String owns heap data, ownership transfers
    let s1 = String::from("hello");
    let s2 = s1;
    // println!("{}", s1); // ERROR: value borrowed after move
    println!("{}", s2); // OK

    // Clone: explicit deep copy, both independent
    let s3 = s2.clone();
    println!("{} {}", s2, s3); // OK, two separate allocations
}

Follow-up Questions

• Why can't a type that owns heap memory implement Copy?
• What is the relationship between the Copy and Clone traits?
• How does moving a value into a function affect the caller?
• When would you derive Clone but not Copy?
• How do move closures capture their environment?