Default Implementation

A default implementation in Rust occurs when a trait provides a concrete method body rather than just a method signature. When a type implements the trait, it automatically inherits this default behavior unless the implementor explicitly overrides the method with a custom definition.

Syntax and Mechanics

To define a default implementation, replace the trailing semicolon of a trait method signature with a block containing the method body.

trait Logger {
    // Required method: implementors MUST provide a body
    fn log_error(&self, msg: &str);

    // Default method: implementors CAN provide a body, or use this one
    fn log_info(&self, msg: &str) {
        println!("[INFO] {}", msg);
    }
}

When implementing the trait for a specific type, you are only required to define methods that lack a default.

struct StandardLogger;

// Inherits the default `log_info` implementation
impl Logger for StandardLogger {
    fn log_error(&self, msg: &str) {
        eprintln!("[ERROR] {}", msg);
    }
}

struct VerboseLogger;

// Overrides the default `log_info` implementation
impl Logger for VerboseLogger {
    fn log_error(&self, msg: &str) {
        eprintln!("[VERBOSE ERROR] {}", msg);
    }

    fn log_info(&self, msg: &str) {
        println!("[VERBOSE INFO] {}", msg);
    }
}

Technical Characteristics

Internal Trait Resolution Default implementations can invoke other methods defined within the same trait, including methods that do not have default implementations. The compiler guarantees that any type implementing the trait will provide the required methods, making the internal call safe at compile time.

trait DataProcessor {
    // Required
    fn fetch_raw_data(&self) -> String;

    // Default implementation calling a required method
    fn process_and_print(&self) {
        let data = self.fetch_raw_data();
        println!("Processed: {}", data.trim());
    }
}

No Super/Base Delegation Unlike class inheritance in object-oriented languages, Rust does not provide a mechanism for an overriding method to call the default implementation (e.g., there is no super::method_name() equivalent). Once a type overrides a default method, the original default implementation is entirely shadowed and inaccessible for that specific type.

Associated Constants and Generic Type Parameters Traits can also provide default values for associated constants and generic type parameters.

// Trait with a default generic type parameter (T = String)
trait Connection<T = String> {
    // Default associated constant
    const TIMEOUT_SECONDS: u32 = 30;

    fn connect(&self, payload: T);
}

struct StandardConnection;

// Uses the default generic type parameter (String)
// Inherits the default associated constant (30)
impl Connection for StandardConnection {
    fn connect(&self, payload: String) {
        // Implementation details
    }
}

struct FastConnection;

// Overrides the generic type parameter with `Vec<u8>`
impl Connection<Vec<u8>> for FastConnection {
    // Overrides the default constant
    const TIMEOUT_SECONDS: u32 = 5;

    fn connect(&self, payload: Vec<u8>) {
        // Implementation details
    }
}

Blanket Implementations vs. Default Implementations A default implementation is bound to the trait definition itself and applies to types explicitly implementing that trait. This differs from a blanket implementation (impl<T> Trait for T), which automatically implements a trait for any type satisfying specific bounds, without requiring an explicit impl block for the target type.

Master Rust with Deep Grasping Methodology!

Learn More