Multiple impl Blocks

Rust allows a single struct or enum to have any number of impl blocks, either within the same file or split across multiple submodules in the same crate. The compiler merges all inherent impl blocks for a type into a single method namespace with zero runtime overhead.

Why Use Multiple impl Blocks?

Splitting methods across multiple impl blocks serves four practical purposes:

Example 1: Partitioning Methods by Trait Bounds

If you placed T: Clone + Ord on a single impl<T: Clone + Ord> Bag<T> block, callers holding a Bag<NonCloneType> would not even be able to call Bag::new() or .len(). Splitting into separate impl blocks ensures each method only requires the exact bounds it uses:

struct Bag<T> {
    items: Vec<T>,
}

// Block 1: No trait bounds required on `T`
impl<T> Bag<T> {
    fn new() -> Self {
        Self { items: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.items.push(item);
    }

    fn len(&self) -> usize {
        self.items.len()
    }
}

// Block 2: Requires `T: PartialEq`
impl<T: PartialEq> Bag<T> {
    fn contains(&self, target: &T) -> bool {
        self.items.contains(target)
    }
}

// Block 3: Requires `T: Ord`
impl<T: Ord> Bag<T> {
    fn max_item(&self) -> Option<&T> {
        self.items.iter().max()
    }
}

struct NonComparable;

fn main() {
    // Works for `NonComparable` even though it implements neither `PartialEq` nor `Ord`:
    let mut raw_bag = Bag::new();
    raw_bag.push(NonComparable);
    println!("raw_bag len = {}", raw_bag.len());

    // `Bag<i32>` unlocks all three `impl` blocks automatically:
    let mut scores = Bag::new();
    scores.push(40);
    scores.push(95);
    scores.push(72);
    println!("Contains 95? {}", scores.contains(&95));
    println!("Max score:   {:?}", scores.max_item());
}

raw_bag len = 1
Contains 95? true
Max score:   Some(95)

Example 2: Distinct impl Blocks for Concrete Generic States

Multiple impl blocks can target distinct concrete instantiations of a generic type parameter, making invalid state transitions unrepresentable at compile time:

struct Locked;
struct Unlocked;

struct Vault<State> {
    secret: String,
    _state: State,
}

impl Vault<Locked> {
    fn new(secret: String) -> Self {
        Self {
            secret,
            _state: Locked,
        }
    }

    fn unlock(self, pin: u16) -> Result<Vault<Unlocked>, Self> {
        if pin == 1234 {
            Ok(Vault {
                secret: self.secret,
                _state: Unlocked,
            })
        } else {
            Err(self)
        }
    }
}

impl Vault<Unlocked> {
    // `.read_secret()` ONLY exists on `Vault<Unlocked>`!
    fn read_secret(&self) -> &str {
        &self.secret
    }

    fn lock(self) -> Vault<Locked> {
        Vault {
            secret: self.secret,
            _state: Locked,
        }
    }
}

fn main() {
    let locked = Vault::new(String::from("launch-codes-2024"));
    // `locked.read_secret()` would not compile here!

    if let Ok(open_vault) = locked.unlock(1234) {
        println!("Secret: {}", open_vault.read_secret());
        let _relocked = open_vault.lock();
    }
}

Secret: launch-codes-2024

Overlapping Inherent Method Definitions Are Forbidden (E0592)

While you can write as many impl blocks as you like for a type, two inherent impl blocks whose type parameters can overlap may not define a method or associated function with the same name:

// ❌ does not compile
struct Wrapper<T>(T);

impl<T> Wrapper<T> {
    fn describe(&self) -> &'static str {
        "generic"
    }
}

impl Wrapper<i32> {
    fn describe(&self) -> &'static str {
        "specialized i32"
    }
}

fn main() {}

error[E0592]: duplicate definitions with name `describe`
  --> src/main.rs:4:5
   |
4  |     fn describe(&self) -> &'static str {
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ duplicate definitions for `describe`
...
10 |     fn describe(&self) -> &'static str {
   |     ---------------------------------- other definition for `describe`