Why traits are used in Rust

Introduction

Traits let us define shared behavior that different types can use. They help write flexible and reusable code.

When you want different types to do the same action in their own way.

When you want to write functions that work with many types that share some behavior.

When you want to organize code by grouping related actions together.

When you want to add new behavior to types without changing their original code.

Syntax

Rust

trait TraitName {
    fn method_name(&self);
}

impl TraitName for TypeName {
    fn method_name(&self) {
        // method code
    }
}

A trait defines methods that types can implement.

Types use impl TraitName for TypeName to provide their own method code.

Examples

This trait Speak has a method say_hello. The Dog type implements it by printing "Woof!".

Rust

trait Speak {
    fn say_hello(&self);
}

struct Dog;

impl Speak for Dog {
    fn say_hello(&self) {
        println!("Woof!");
    }
}

The Area trait requires an area method. Circle calculates its area using its radius.

Rust

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

struct Circle {
    radius: f64,
}

impl Area for Circle {
    fn area(&self) -> f64 {
        3.14 * self.radius * self.radius
    }
}

Sample Program

This program defines a trait Greet with a method greet. The Person struct implements it to say hello with the person's name.

Rust

trait Greet {
    fn greet(&self);
}

struct Person {
    name: String,
}

impl Greet for Person {
    fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

fn main() {
    let p = Person { name: String::from("Alice") };
    p.greet();
}

Important Notes

Traits are like promises that a type will have certain methods.

You can use traits to write code that works with many types, as long as they implement the trait.

Summary

Traits define shared behavior for different types.

They help make code flexible and reusable.

Types implement traits to provide their own version of the behavior.