السمات وحدود السمات

Traits define the behavior that a particular type has and can share with other types. We can use traits to define a set of methods that represent a certain common functionality or interface, similar to interfaces in other programming languages.

Trait bounds allow us to specify that a generic type must implement a specific trait, ensuring that the required methods are available at compile time.

Defining and Implementing a Trait

To define a trait, we use the trait keyword followed by the signatures of the methods that implementing types must define:

pub trait Summary {
    fn summarize(&self) -> String;
}

To implement a trait on a concrete type, we use the syntax impl TraitName for TypeName:

pub struct NewsArticle {
    pub headline: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}", self.headline)
    }
}

Trait Bounds

When writing generic functions, we can constrain the type parameters to ensure they implement a specific trait. The standard syntax is <T: Trait>:

pub fn notify<T: Summary>(item: &T) {
    println!("Notification: {}", item.summarize());
}

Alternatively, for more complex signatures, we can use the where clause:

pub fn notify_advanced<T>(item: &T)
where
    T: Summary
{
    println!("Notification: {}", item.summarize());
}

Try it yourself

Exercise 1: The Summary Trait

Exercise 2: Trait Bounds with print_summary

Exercise 3: Area Calculation using Traits