How can I add extension methods to a trait with associated types lying in a different crate?

Question

I'm trying to add an extension method to a trait in a different crate. This trait has an associated type specified on it.

pub trait Test<W> {
    type Error;

    fn do_sth(&mut self) -> Result<W, Self::Error>;
}

Why is it not possible to add a method that is using the associated type Error?

impl dyn Test<u8> {
    fn use_do_sth(&mut self) -> Result<u8: Self::Error> {
        self.do_sth()
    }
}

playground

Answer 1

When you need to add a method to the external type, the only option is to use extension traits. It means that you define your own trait, with whatever methods you need, and implement it for the types you need.

When you need to add a method to all types implementing some external trait, you can use the same pattern, but instead of listing the types directly, just use the trait bound:

use std::fmt::Debug;

// This is an extension trait.
// You can force all its implementors to implement also some external trait,
// so that two trait bounds essentially collapse into one.
trait HelperTrait: Debug {
    fn helper_method(&mut self);
}

// And this is the "blanket" implementation,
// covering all the types necessary.
impl<T> HelperTrait for T where T: Debug {
    fn helper_method(&mut self) {
        println!("{:?}", self);
    }
}

Playground

The same idea could be applied to any external trait, as you wish.

Answer 2

Do you want the following?

impl<E> dyn Test<u8, Error = E> {
    fn use_do_sth(&mut self) -> Result<u8, E> {
        self.do_sth()
    }
}

I came up with this following the compiler's hint that "the value of the associated type Error must be specified".