Traits: Defining Shared Behavior

In Rust, traits are a powerful feature that allows you to define shared behavior, or a set of methods, that types can implement. They are similar to interfaces in other languages (like Java or Go) or abstract base classes in C++. Traits enable polymorphism, allowing you to write generic code that can operate on different types as long as they implement a particular trait.

What are Traits?
A trait is essentially a contract. It declares a list of method signatures that a type must implement if it wants to be considered as having that trait. Traits do not contain data fields, only method signatures (and optionally, default method implementations).

Why Use Traits?
1. Shared Functionality: Define a common set of methods that multiple, otherwise unrelated, types can share.
2. Polymorphism: Write functions that accept any type that implements a certain trait, allowing your code to work with a variety of types in a unified way.
3. Code Reusability: By defining behavior once in a trait, you can apply it to many different types.
4. Compile-Time Safety: The Rust compiler ensures that any type claiming to implement a trait actually provides concrete implementations for all required methods.

Defining a Trait:
A trait is defined using the `trait` keyword, followed by the trait name and a block containing method signatures.

```rust
trait MyTrait {
fn method1(&self) -> String;
fn method2(&mut self, value: u32);
// Optional: default method implementation
fn default_method(&self) {
println!("This is a default implementation.");
}
}
```

Implementing a Trait:
To make a specific type (like a `struct` or `enum`) implement a trait, you use the `impl` keyword followed by the trait name, the `for` keyword, and the type name. You then provide concrete implementations for all methods declared in the trait (unless they have default implementations).

```rust
struct MyStruct { /* ... */ }

impl MyTrait for MyStruct {
fn method1(&self) -> String {
"Implementation for MyStruct".to_string()
}
fn method2(&mut self, value: u32) {
// ... logic for MyStruct ...
}
// No need to implement default_method if we want to use the default
}
```

Using Traits (Trait Bounds):
The most common way to use traits for shared behavior is through trait bounds on generic functions. This allows a function to accept any type `T` that implements a specific trait `MyTrait`.

```rust
fn process_item<T: MyTrait>(item: &T) {
println!("Processing: {}", item.method1());
item.default_method(); // Can call default methods too
}
```

Traits are fundamental to writing flexible, extensible, and type-safe code in Rust, enabling you to define common interfaces and leverage compile-time polymorphism.

```rust
// 1. Define a trait named `Printable`
// This trait specifies a contract: any type implementing it must provide
// a `print_details` method that takes an immutable reference to self
// and returns nothing.
trait Printable {
    fn print_details(&self);
}

// 2. Define a struct `Book`
struct Book {
    title: String,
    author: String,
    pages: u32,
}

// 3. Implement the `Printable` trait for `Book`
impl Printable for Book {
    fn print_details(&self) {
        println!("Book: \"{}\" by {} ({} pages)", self.title, self.author, self.pages);
    }
}

// 4. Define another struct `Article`
struct Article {
    headline: String,
    author: String,
    word_count: u32,
}

// 5. Implement the `Printable` trait for `Article`
impl Printable for Article {
    fn print_details(&self) {
        println!("Article: \"{}\" by {} ({} words)", self.headline, self.author, self.word_count);
    }
}

// 6. Define a generic function `display_item` that takes any type `T`
// as long as `T` implements the `Printable` trait. This is called a "trait bound".
// This function can now work with both `Book` and `Article` because they both
// implement `Printable`.
fn display_item<T: Printable>(item: &T) {
    println!("--- Displaying item details ---");
    item.print_details(); // Call the trait method on the item
    println!("-------------------------------");
}

fn main() {
    // Create instances of our structs
    let my_book = Book {
        title: String::from("The Rust Programming Language"),
        author: String::from("Steve Klabnik and Carol Nichols"),
        pages: 600,
    };

    let my_article = Article {
        headline: String::from("Understanding Rust Traits"),
        author: String::from("Rust Enthusiast"),
        word_count: 1500,
    };

    // Use the generic `display_item` function with different types
    // because they both satisfy the `Printable` trait bound.
    display_item(&my_book);
    display_item(&my_article);

    // You can also directly call the method if you know the concrete type
    my_book.print_details();
    my_article.print_details();
}
```