Traits: The "Contract" System

ABSTRACT: 🧩 Analogy for Frontend Developers

A Trait in Rust is exactly like an interface in TypeScript.

Think of a Trait as a Contract or a Job Description. It is a way to define shared behavior in an abstract way, forcing different types of data to share the exact same capabilities.

🏗️ The 3-Step Breakdown

1. Writing the Contract (Defining a Trait)

Imagine you have two different data structures: a NewsArticle and a SocialPost. You want to be able to print a short summary of both of them. So, you create a “Contract” (a Trait) called Summary.

pub trait Summary {
    // The contract says: "To sign this, you MUST have a function called summarize"
    fn summarize(&self) -> String;
}

NOTE: > At this point, you aren’t writing how to summarize anything. You are just making the rule that anything calling itself a Summary must have this function.

2. Signing the Contract (Implementing the Trait)

Now you make your data types “sign” the contract by writing the exact custom code for how that specific data type should be summarized.

// 1. The NewsArticle signs the contract
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("Headline: {}, by {}", self.headline, self.author)
    }
}

// 2. The SocialPost signs the exact same contract
impl Summary for SocialPost {
    fn summarize(&self) -> String {
        format!("Tweet from {}: {}", self.username, self.content)
    }
}

3. The Magic: Using the Contract

With Traits, you can write one single function that accepts anything, as long as it has signed the Summary contract!

// The `impl Summary` means: "I will accept ANY data type here,
// but ONLY if it has signed the Summary contract!"
pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

Because the Rust compiler knows that both NewsArticle and SocialPost signed the contract, it will happily let you pass either of them into this function.

TIP: 🏗️ Default Behavior

Rust also allows you to put a default behavior directly inside the contract, so if a data type is too lazy to write its own custom summary, it will just use the default one automatically!

⚓ Important Built-in Rust Traits (Contracts)

Rust has several incredibly useful Traits built directly into the standard library. Because they are so common, Rust even gives you a magic shortcut called the derive attribute (written as #[derive(...)]) to automatically write the code to “sign” some of these contracts for you.

1. Clone (The Deep Copy Contract)

By default, complex data in Rust (like Strings or Structs) is “moved” when you assign it to a new variable, meaning the old variable becomes invalid to keep memory safe.

If you want to explicitly create a deep copy of a value (copying the actual heap data so both variables are valid), the type must implement the Clone trait.

• What it unlocks: It gives your type the .clone() method.
• How to sign it: You can automatically implement it by placing #[derive(Clone)] above your struct or enum.

#[derive(Clone)]
struct Point { x: i32, y: i32 }

let p1 = Point { x: 5, y: 10 };
let p2 = p1.clone(); // Safely creates a deep copy!

2. Display (The User-Facing Print Contract)

The Display trait is the contract for formatting your data so it looks nice for an end user.

• What it unlocks: It allows you to print your type using the standard {} placeholder in println! or format! macros.
• How to sign it: You cannot use the #[derive] shortcut for this one. Rust refuses to guess how you want to display your data to your users, so you must manually write the implementation.

use std::fmt;

struct Point { x: i32, y: i32 }

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

let p = Point { x: 5, y: 10 };
println!("The point is {}", p); // Prints: The point is (5, 10)

3. Debug (The Developer-Facing Print Contract)

While Display is for end users, the Debug trait is specifically for programmers to inspect data during debugging.

• What it unlocks: It allows you to print the internal state of your struct using the {:?} placeholder (or {:#?} for “pretty” multi-line formatting).
• How to sign it: Because it’s just for developers, you don’t have to write it manually! You can automatically generate the implementation using #[derive(Debug)].

// Auto-signing the Debug contract
#[derive(Debug)]
struct Rectangle { width: u32, height: u32 }

let rect = Rectangle { width: 30, height: 50 };

// Using {:?} to print developer-friendly output
println!("rect is {:?}", rect);
// Prints: rect is Rectangle { width: 30, height: 50 }