Implementing Deref on a struct that owns a boxed trait

Question

I'd like to implement Deref and DefrefMut on a struct that owns a boxed trait, e.g.:

use std::ops::{Deref, DerefMut};

trait Quack {
    fn quack(&self);
}

struct QuackWrap {
    value: Box<Quack>
}

impl Deref for QuackWrap {
    type Target = Box<Quack>;

    fn deref<'a>(&'a self) -> &'a Box<Quack> {
        &self.value
    }
}

impl DerefMut for QuackWrap {
    fn deref_mut<'a>(&'a mut self) -> &'a mut Box<Quack> {
        &mut self.value
    }
}

This fails to compile with the following error:

src/main.rs:14:5: 16:6 error: method `deref` has an incompatible type for trait: expected bound lifetime parameter 'a, found concrete lifetime [E0053]
src/main.rs:14     fn deref<'a>(&'a self) -> &'a Box<Quack> {
src/main.rs:15         &self.value
src/main.rs:16     }
src/main.rs:20:5: 22:6 error: method `deref_mut` has an incompatible type for trait: expected bound lifetime parameter 'a, found concrete lifetime [E0053]
src/main.rs:20     fn deref_mut<'a>(&'a mut self) -> &'a mut Box<Quack> {
src/main.rs:21         &mut self.value
src/main.rs:22     }

If I replace Box<Quack> with Box<String> (or a similar type), it works. The problem is that Quack is a trait. But I'm not sure why that generated the error message it did. Any ideas?

My question is similar to another SO question, but not quite the same. In that question, the struct has a type parameter with the trait as a constraint. Whereas in my question, there is no type parameter.

I don't want to confuse the issues, but there's a good reason that I need Box<Quack> in my application. I.e. I can't replace Quack with a type parameter. In case you care, the reason is discussed further in another SO question.

`type Target = Box;` is `type Target = Box;`, and `&'a Box` is `&'a Box`. — Chris Morgan, Jun 05 '15 at 23:08

score 7 · Accepted Answer · edited Jun 05 '15 at 18:43

7

When in doubt, add more lifetime annotations:

use std::ops::{Deref, DerefMut};

trait Quack {
    fn quack(&self);
}

struct QuackWrap<'b> {
    value: Box<Quack + 'b>
}

impl<'b> Deref for QuackWrap<'b>{
    type Target = Box<Quack + 'b>;

    fn deref<'a>(&'a self) -> &'a Box<Quack + 'b> {
        &self.value
    }
}

impl<'b> DerefMut for QuackWrap<'b> {
    fn deref_mut<'a>(&'a mut self) -> &'a mut Box<Quack + 'b> {
        &mut self.value
    }
}

edited Jun 05 '15 at 18:43

Shepmaster

388,571
95
1,107
1,366

answered Jun 05 '15 at 18:30

Brian Campbell

322,767
57
360
340

4

Specifically, this helps because `struct QuackWrap { value: Box }` is equivalent to `struct QuackWrap { value: Box }`. – Shepmaster Jun 05 '15 at 18:44
@Shepmaster Thanks for the explanation. I didn't know precisely which implicit lifetime was being added where, so I left my answer as just the fix. Answering why this broke in the first place is quite helpful. – Brian Campbell Jun 05 '15 at 19:02

score 1 · Answer 2 · answered Jun 05 '15 at 21:09

Based on Brian's answer and Shepmaster's explanation, I updated my code as follow. I also simplified the QuackWrap struct. (That wasn't strictly necessary, but it's arguably better style than what I was doing before.)

use std::ops::{Deref, DerefMut};

trait Quack {
    fn quack(&self);
}

struct QuackWrap(Box<Quack>);

impl Deref for QuackWrap {
    type Target = Box<Quack + 'static>;

    fn deref<'a>(&'a self) -> &'a Box<Quack + 'static> {
        let QuackWrap(ref v) = *self;
        v
    }
}

impl DerefMut for QuackWrap {
    fn deref_mut<'a>(&'a mut self) -> &'a mut Box<Quack + 'static> {
        let QuackWrap(ref mut v) = *self;
        v
    }
}

There may be a more concise way to destructure QuackWrap in the deref and deref_mut implementations. Some of those more obscure syntax rules elude me. But for now this is fine.

*There may be a more concise way ...* — Newtypes (and all tuple structs) offer positional accessors. Here's a [slightly smaller example](http://is.gd/Q6weUR) — Shepmaster, Jun 05 '15 at 23:41

Implementing Deref on a struct that owns a boxed trait

2 Answers2