9.9 Derived Traits

Rust can automatically provide many common behaviors for structs via derived traits. Traits define shared behaviors, and the #[derive(...)] attribute instructs the compiler to generate default implementations.

9.9.1 Common Derived Traits

Frequently used derived traits include:

  • Debug: Formats struct instances for debugging ({:?}).
  • Clone: Makes explicit deep copies of instances.
  • Copy: Allows a simple bitwise copy, requiring that all fields are also Copy.
  • PartialEq / Eq: Enables comparing structs using == and !=.
  • Default: Creates a default value for the struct.

9.9.2 Example: Using the Debug Trait

fn main() {
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

    let p = Point { x: 1, y: 2 };
    println!("{:?}", p);    // Compact debug output
    println!("{:#?}", p);   // Pretty-printed debug output
}

Deriving traits like Debug reduces boilerplate code and is particularly handy for quick debugging and testing.

9.9.3 Implementing Traits Manually

When you require more control—such as custom formatting—you can implement traits yourself:

impl std::fmt::Display for Point {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "Point({}, {})", self.x, self.y)
    }
}

This approach is useful when the default derived implementations don’t meet specific requirements.

9.9.4 Comparing Rust Structs with OOP Concepts

Programmers familiar with OOP (C++, Java, C#) will see some parallels:

  • Structs + impl resemble classes.
  • No inheritance: Rust uses traits for polymorphism.
  • Encapsulation: Controlled through pub to expose functionality explicitly.
  • Ownership and borrowing: Replace garbage collection or manual memory management.

Rust’s trait-based model offers safety, flexibility, and performance without classical inheritance.