Move Semantics & Copy

Assignment and passing by value either move (transfer ownership) or copy (duplicate bits) depending on the type. Clone provides explicit duplication when needed.

Recipe

#[derive(Clone, Debug)]
struct Config { host: String, port: u16 }
 
fn main() {
    let port: u16 = 8080; // Copy
    let p2 = port;
 
    let cfg = Config { host: "localhost".into(), port };
    let cfg2 = cfg.clone(); // explicit deep copy
    println!("{port} {:?} {:?}", cfg, cfg2);
}

When to reach for this: Deciding whether a type should be Copy, when to clone(), and designing APIs that move vs borrow.

Working Example

#[derive(Copy, Clone, Debug)]
struct Point { x: i32, y: i32 }
 
fn translate(p: Point, dx: i32) -> Point {
    Point { x: p.x + dx, y: p.y }
}
 
fn main() {
    let origin = Point { x: 0, y: 0 };
    let moved = origin; // Copy - both valid
    let shifted = translate(moved, 5);
    println!("{origin:?} {shifted:?}");
}

What this demonstrates:

• Point is Copy because all fields are Copy
• origin remains usable after assignment
• Small stack-only aggregates are good Copy candidates
• String cannot be Copy (heap ownership)

Deep Dive

Move Semantics

• Non-Copy assignment invalidates the source binding
• Moves are cheap for heap types (pointer copy)
• Function parameters by value take ownership unless borrowed
• Vec, String, HashMap always move on assignment

Copy Requirements

// All fields Copy, no Drop impl (usually)
#[derive(Copy, Clone)]
struct Flags(u32);

Types with custom Drop generally cannot be Copy.

Clone vs Copy

Clone on Collections

let v1 = vec![1, 2];
let v2 = v1.clone(); // clones elements if T: Clone

Gotchas

• Deriving Copy on struct with String - Compile error. Fix: Remove Copy or use &str/Arc<str> if sharing needed.
• Cloning in loops - Hides performance issues. Fix: Restructure to borrow or reuse buffers.
• Assuming assignment copies Vec - It moves. Fix: .clone() explicitly when duplicate needed.
• Copy + Drop conflict - Custom drop means move semantics matter. Fix: Do not implement Copy.
• Partial move then use struct - Moved fields invalidate whole struct use in some cases. Fix: Destructure or borrow fields.

Alternatives

FAQs

Related

• Ownership Basics - single-owner rule
• Borrowing & References - avoid moves
• Rc & Arc - shared ownership
• Cow - clone on demand

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.