Default Parameters for Trait Methods

In this lesson, you will learn how to add methods to your traits with default implementations, allowing you to extend existing interfaces without breaking the code of anyone who has already implemented your trait.

The Problem of Evolution

Imagine you have defined a trait called Loggable that requires types to implement a log_message method. Many developers in your ecosystem have already implemented this for their own structs. Later, you decide that every Loggable should also support a log_error method. If you simply add fn log_error(&self); to the trait, every single one of those developers will find their code failing to compile because they haven't implemented the new requirement.

Providing a Default

Rust allows you to provide a default implementation directly within the trait definition. If a developer doesn’t provide their own version, Rust will use your default.

trait Loggable {
    fn log_message(&self, msg: &str);

    // This is the default method
    fn log_error(&self, msg: &str) {
        println!("Error: {}", msg);
    }
}

Now, if someone implements Loggable, they only must provide log_message. The log_error method is automatically available on their type. If they want to customize the behavior of log_error (for example, to write to a specific file instead of printing to the console), they can simply override it in their impl block:

struct MyService;

impl Loggable for MyService {
    fn log_message(&self, msg: &str) {
        println!("Info: {}", msg);
    }
    
    // Optional: Override the default
    fn log_error(&self, msg: &str) {
        eprintln!("CRITICAL ERROR: {}", msg);
    }
}

Why This Matters

Default methods provide a "graceful evolution" path for your APIs. By providing a base implementation, you ensure that your trait remains forward-compatible. You aren't forcing downstream users to touch their existing code unless they specifically need custom behavior for the new functionality. This keeps your library robust and prevents the "breaking changes" nightmare that occurs when interface requirements change over time.

Key Takeaway: Default trait methods allow you to extend the functionality of a trait by providing a fallback implementation, ensuring backward compatibility for all existing trait implementations.