Why Defining traits in Rust? - Purpose & Use Cases

The Big Idea

What if you could make different things act the same way without rewriting code again and again?

The Scenario

Imagine you want to create different types of vehicles in your program, like cars and bikes, and each vehicle should be able to start and stop. Without traits, you have to write separate functions for each vehicle type, repeating similar code everywhere.

The Problem

This manual way is slow and error-prone because you must remember to write the same functions for every new vehicle type. If you forget or make a mistake, your program breaks or behaves inconsistently.

The Solution

Defining traits lets you create a shared blueprint for behavior, like "start" and "stop" methods, that different types can implement. This way, you write the behavior once and ensure all types follow it, making your code cleaner and safer.

Before vs After

✗ Before

struct Car {}
impl Car {
    fn start(&self) {
        println!("Car started");
    }
}
struct Bike {}
impl Bike {
    fn start(&self) {
        println!("Bike started");
    }
}

✓ After

trait Vehicle {
    fn start(&self);
    fn stop(&self);
}
struct Car {}
impl Vehicle for Car {
    fn start(&self) {
        println!("Car started");
    }
    fn stop(&self) {
        println!("Car stopped");
    }
}
struct Bike {}
impl Vehicle for Bike {
    fn start(&self) {
        println!("Bike started");
    }
    fn stop(&self) {
        println!("Bike stopped");
    }
}

What It Enables

It enables writing flexible and reusable code where different types share common behavior without repeating yourself.

Real Life Example

Think of a music app where different audio players (like MP3, WAV, or streaming) all implement a trait to play, pause, and stop music, so the app controls them all the same way.

Key Takeaways

Traits define shared behavior blueprints for different types.

They prevent code repetition and reduce errors.

Traits make your code easier to extend and maintain.