Rust Derive Traits Practice: Debug, Clone, PartialEq & More

Copy requires every field to be Copy (stack-only, no heap data). Types with String, Vec, or Box fields — or types implementing Drop — cannot be Copy:

// WRONG: String is heap-allocated, not Copy
// #[derive(Copy, Clone)]
// struct User {
//     name: String,  // error[E0204]
//     age: u32,
// }

// RIGHT: Use Clone without Copy
#[derive(Clone)]
struct User {
    name: String,
    age: u32,
}

// Copy is fine for stack-only types
#[derive(Copy, Clone)]
struct Point {
    x: f64,
    y: f64,
}

Rule of thumb: derive Copy on small value types (coordinates, colors, flags). Use Clone for everything else. The traits and generics guide covers how derive macros generate trait implementations under the hood.

HashMap requires keys to implement all three traits. Missing any one produces a compile error:

// WRONG: Hash without Eq
// #[derive(Hash)]
// struct Key { id: u32 }
// let map: HashMap<Key, String>;  // error[E0277]: Key doesn't implement Eq

// RIGHT: Derive the complete bundle
#[derive(Debug, Hash, PartialEq, Eq)]
struct Key {
    id: u32,
    name: String,
}

let mut map = std::collections::HashMap::new();
map.insert(Key { id: 1, name: "a".into() }, "value".into());

The bundle is always Hash + PartialEq + Eq. If your key contains floats, you cannot derive Eq (see Ord/PartialOrd below).

Derived Default works on enums by marking one unit variant with #[default]:

#[derive(Default, Debug)]
enum Status {
    #[default]
    Pending,
    Active,
    Inactive,
}

let status = Status::default();
println!("{status:?}"); // Pending

Exactly one variant must be marked #[default], and it must be a unit variant (no fields).

Derived ordering compares fields in definition order (first field, then second as tiebreaker, etc.):

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
struct Score {
    points: i32,
    name: String,
}

let mut scores = vec![
    Score { points: 90, name: "Alice".into() },
    Score { points: 85, name: "Bob".into() },
];
scores.sort();  // sorts by points, then name

Float gotcha: f32 and f64 implement PartialOrd but not Ord, because NaN != NaN breaks total ordering. You cannot derive Ord on types containing floats:

// WRONG: f64 is not Ord
// #[derive(Ord, PartialOrd, PartialEq, Eq)]
// struct Measurement { value: f64 }  // error[E0277]

// Workaround: use the ordered-float crate, or implement Ord manually
// with a NaN policy (e.g., treat NaN as greater than all values)

When you derive a trait on a generic struct, the compiler adds trait bounds to the generated impl:

#[derive(Clone, Debug)]
struct Wrapper<T>(T);
// The compiler generates:
// impl<T: Clone> Clone for Wrapper<T> { ... }
// impl<T: Debug> Debug for Wrapper<T> { ... }

This means Wrapper<T> is only Clone when T is Clone. If you need different bounds, implement the trait manually. For the full trait bound syntax, see the traits cheat sheet.

Derive uses "all fields" semantics — it includes every field in the comparison, hash, debug output, etc. The structs and enums guide covers how field definitions work alongside derive macros. Implement manually when:

• Equality should ignore some fields — e.g., skip internal IDs, caches, or timestamps
• Debug should hide sensitive data — e.g., mask passwords or tokens
• Default needs non-zero values — e.g., a config with retries: 3 instead of 0
• Clone needs special logic — e.g., resetting a counter on clone

// Manual PartialEq: compare only the meaningful fields
struct User {
    id: u64,       // internal, skip
    name: String,  // compare this
    email: String, // compare this
}

impl PartialEq for User {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name && self.email == other.email
    }
}
impl Eq for User {}

// Struct with common derives
#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

// Tuple struct as a newtype
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct Color(u8, u8, u8);

// Struct with Default
#[derive(Default)]
struct Config {
    verbose: bool,      // defaults to false
    count: i32,         // defaults to 0
    name: String,       // defaults to ""
}
let config = Config::default();

// Enum with Debug
#[derive(Debug)]
enum Status {
    Active,
    Inactive,
    Pending(String),
}

• The Rust Book: Derivable Traits — all standard derivable traits
• Rust Reference: Derive — how derive macros expand
• std::marker::Copy — Copy requirements and E0204
• std::default::Default — Default on enums with #[default]