Default Trait Implementations

In this lesson, you will learn how to reduce repetitive code by defining baseline behavior directly within a trait definition.

Simplifying Traits with Default Implementations

When defining a trait, you don't always need to force the user to implement every single function. If there is a logical "standard" way for a type to behave, you can provide a default implementation inside the trait block itself.

This is a powerful tool for API design. It allows you to create a "minimal complete implementation" for your users, where they only need to override the methods that are specific to their unique data, while inheriting the rest for free.

Seeing it in Practice

Imagine we are building a Logger trait. Most loggers share the same logic for printing an "info" message, but the actual "write" operation might change depending on whether we are logging to a file, the console, or a network socket.

trait Logger {
    // This requires a custom implementation
    fn write_raw(&self, message: &str);

    // This provides a default implementation!
    fn log_info(&self, message: &str) {
        let formatted = format!("[INFO]: {}", message);
        self.write_raw(&formatted);
    }
}

Now, when someone implements Logger for their own type, they only have to worry about write_raw. Because log_info already has a body, they get that functionality automatically:

struct ConsoleLogger;

impl Logger for ConsoleLogger {
    fn write_raw(&self, message: &str) {
        println!("{}", message);
    }
}

// ConsoleLogger now has access to .log_info() automatically!

Why use this?

1. Reduce Boilerplate: You avoid forcing users to rewrite the same utility code for every single type.
2. Backward Compatibility: You can add new methods to a trait later without breaking existing code, provided you give them a default implementation.
3. Encapsulation: You hide the "how" of the utility logic while exposing the "what" of the trait interface.

Keep in mind that if a user wants a different behavior, they can always override the default function in their impl block just like any other method.

Key Takeaway: Default trait implementations allow you to define shared, baseline behavior in one place, significantly reducing the amount of code required to implement a trait for new types.