Implementing Blanket Traits Responsibly

In this lesson, you will learn how to implement blanket traits without triggering "coherence errors" that block your code from compiling.

What is a Blanket Trait?

A blanket trait is an implementation that covers a broad range of types using generics. For example, you might want to implement a Describable trait for every type that implements ToString:

trait Describable {
    fn describe(&self) -> String;
}

impl<T: ToString> Describable for T {
    fn describe(&self) -> String {
        format!("Value: {}", self.to_string())
    }
}

This is powerful, but it’s a "blanket" implementation. Rust’s coherence rules exist to ensure that there is never any ambiguity about which implementation should be used. If you try to add another implementation for a specific type—like impl Describable for i32—the compiler will stop you.

Why Coherence Errors Occur

The compiler protects you from overlapping implementations. If you define a blanket implementation for T: ToString, and then later try to define a specific implementation for i32, the compiler sees that i32 already implements ToString. It doesn't know whether to use your "blanket" logic or your "specific" logic for i32. This creates an ambiguity that Rust refuses to allow.

How to Implement Responsibly

To avoid these conflicts, follow these two rules:

1. The Orphan Rule: You can only implement a trait if either the trait or the type is local to your crate. If you are trying to implement a foreign trait (like Display) for a foreign type (like Vec<T>), you cannot use a blanket implementation.
2. Specialization Limitation: Understand that in stable Rust, you cannot "override" a blanket trait for a specific type. If your library provides a blanket implementation, users of your library cannot provide their own implementation for types that fall under your blanket.

If you find yourself needing to define a blanket trait, ensure that the trait itself is defined within your crate. If the trait is external, stick to specific, non-generic implementations to keep your code predictable and compatible with other crates.

Key Takeaway: Blanket traits define a universal rule for a set of types; once defined, you cannot add specific overrides for any type covered by that blanket without violating Rust's coherence rules.