What is a Trait?

A trait in Rust is similar to an interface in other programming languages. It defines a set of methods that types can implement. Traits allow different types to be treated uniformly when they share common behavior. This is particularly useful in generic programming, where you want to write functions that can operate on different types.

Defining a Trait

To define a trait, use the trait keyword followed by the trait name and a block containing method signatures. Here's a simple example:

trait Shape {
    fn area(&self) -> f64;
    fn perimeter(&self) -> f64;
}

In this example, the Shape trait defines two methods: area and perimeter, which any type implementing this trait must provide.

Implementing a Trait

To implement a trait for a specific type, use the impl keyword followed by the trait name and the type. Here’s how to implement the Shape trait for a Rectangle struct:

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }

    fn perimeter(&self) -> f64 {
        2.0 * (self.width + self.height)
    }
}

Similarly, you can implement the Shape trait for a Circle struct:

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }

    fn perimeter(&self) -> f64 {
        2.0 * std::f64::consts::PI * self.radius
    }
}

Using Traits

Once a trait is implemented for a type, you can use it in functions that accept trait objects or generic parameters. Here’s an example of a function that takes any type implementing the Shape trait:

fn print_shape_info<T: Shape>(shape: &T) {
    println!("Area: {}", shape.area());
    println!("Perimeter: {}", shape.perimeter());
}

You can call this function with both Rectangle and Circle instances:

fn main() {
    let rect = Rectangle { width: 5.0, height: 3.0 };
    let circle = Circle { radius: 4.0 };

    print_shape_info(&rect);
    print_shape_info(&circle);
}

Trait Bounds

Trait bounds allow you to specify that a generic type must implement a particular trait. This is useful for ensuring that the types you work with have the necessary methods defined. Here’s an example of using trait bounds in a generic function:

fn total_area<T: Shape>(shapes: &[T]) -> f64 {
    shapes.iter().map(|shape| shape.area()).sum()
}

You can now use this function to calculate the total area of a collection of shapes:

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Rectangle { width: 5.0, height: 3.0 }),
        Box::new(Circle { radius: 4.0 }),
    ];

    let area = total_area(&shapes);
    println!("Total area: {}", area);
}

Default Method Implementations

Traits can also provide default implementations for methods. This allows types to inherit common behavior without needing to implement every method. Here’s how to add a default method to the Shape trait:

trait Shape {
    fn area(&self) -> f64;
    fn perimeter(&self) -> f64;

    fn description(&self) -> String {
        format!("Area: {}, Perimeter: {}", self.area(), self.perimeter())
    }
}

Types that implement the Shape trait can choose to override the description method or use the default implementation.

Conclusion

Traits are a fundamental aspect of Rust that promote code reusability and abstraction. By defining shared behavior through traits, you can create flexible and maintainable code that works with various types. Using trait bounds and default method implementations further enhances the power of traits in Rust.

Learn more with useful resources