Rust - implementing trait for Deref: the parameter type `T` may not live long enough

Question

I have a trait:

trait Foo {
    fn bar(&self) -> Cow<str>;
}

And I want to implement it for any type that implements Deref with a target of a type that implements Foo. Basically:

impl<T: Foo, D: std::ops::Deref<Target = T>> Foo for D {
    fn bar(&self) -> Cow<str> {
        <T as Foo>::bar(std::ops::Deref::deref(self))
    }
}

Unfortunately, this gives the error the parameter type T may not live long enough.

My understanding is that T could have a reference within it that has a short lifetime, and the lifetime bound of the return value of Cow<str> is linked to the lifetime of &self due to lifetime elision, which would cause problems.

I'm not sure how I can fix this, since I'm not able to bound any of the lifetimes in bar. I can try to make sure T lives as long as &self, but this doesn't work.

impl<'a, T: Foo + 'a, D: std::ops::Deref<Target = T>> Foo for D {
    fn bar(&'a self) -> Cow<'a, str> {
        <T as Foo>::bar(std::ops::Deref::deref(self))
    }
}

I get the error method not compatible with trait since the lifetimes don't match the trait defenition anymore. I've tried all sorts of different ways of adding lifetime bounds and I always get one of those two errors.

I am able to implement Foo for a specific type that implements Deref:

impl<T: Foo> Foo for Box<T> {
    fn bar(&self) -> Cow<str> {
        <T as Foo>::bar(self)
    }
}

I'm not sure why that works but the original example doesn't.

Answer 1

The Box version works because of the deref coercion the compiler will do when it sees a reference and expects a different reference. You can use the same mechanic when using a generic implementor of Deref to ensure that it Derefs to an owned type you can simply add a 'static lifetime bound on T like this:

impl<T: Foo + 'static, D: std::ops::Deref<Target = T>> Foo for D {
    fn bar(&self) -> Cow<str> {
        <T as Foo>::bar(self)
    }
}

playground

Note: there is rarely a need to call methods of std::ops traits directly, they're all just the methods behind Rusts operators, deref for example is the method behind unary *

---

Update:

Since there is an additional requirement that T might not be static we have to thread through the lifetime like you tried in your second example, like the error you're getting suggest you have to adjust the trait to take a lifetime as well:

use std::borrow::Cow;
trait Foo<'a> {
    fn bar(&self) -> Cow<'a, str>;
}

impl<'a, T: Foo<'a>, D: std::ops::Deref<Target = T>> Foo<'a> for D {
    fn bar(&self) -> Cow<'a, str> {
        <T as Foo>::bar(self)
    }
}

struct S<'a> {
    val: &'a str,
}

impl<'a> Foo<'a> for S<'a> {
    fn bar(&self) -> Cow<'a, str> {
        todo!()
    }
}

fn main() {
    let val = String::from("test");
    let s = S { val: &val }; // error: `val` does not live long enough
    let b = Box::new(s);
    let cow = Foo::bar(&b); // argument requires that `val` is borrowed for `'static`
}