Blanket Implementations

In this lesson, you will learn how to write a single implementation block that adds functionality to every type that satisfies a specific trait bound.

What are Blanket Implementations?

So far, we have implemented traits for specific types, like impl MyTrait for MyStruct. But what if you want to add a helper method to every type that implements Display, or to every type that is Clone?

A blanket implementation allows you to do exactly that. By using a generic trait bound in your impl block, you define behavior once, and the Rust compiler automatically applies it to every type—past, present, and future—that satisfies that bound.

A Concrete Example

Imagine you want a quick way to print a message to the console for any type that implements std::fmt::Display. Instead of writing a function for each type, you can use a blanket implementation:

use std::fmt::Display;

trait SayHello {
    fn say_hello(&self);
}

// Blanket implementation: 
// Any type T that implements Display automatically gets SayHello
impl<T: Display> SayHello for T {
    fn say_hello(&self) {
        println!("Hello! My value is: {}", self);
    }
}

fn main() {
    let x = 42;
    let y = "Rust";
    
    x.say_hello(); // Works!
    y.say_hello(); // Also works!
}

In this code, we didn't write an implementation for i32 or &str. Because they both implement Display, they "inherit" the say_hello method automatically through our blanket implementation.

Why use them?

This pattern is essential for extending the capabilities of existing types without modifying their original code. It effectively acts as a way to provide "default" behavior for any type that fits into a category you define.

You see this in the Rust standard library constantly; for example, the ToString trait is implemented for any type that implements Display. By defining your own blanket implementations, you can provide similarly powerful, ergonomic tools for your own generic systems.

Key Takeaway: A blanket implementation uses a generic trait bound to attach methods to an entire family of types simultaneously, significantly reducing boilerplate code.