Rust traits on newtypes

Question

Let's say I have defined a Group trait with all the group operations. Would it be possible to create a wrapper AGroup over Group without having to manually derive all its operations?

Basically, I'd like to have this:

#[derive (Copy, Debug, Clone, Eq, PartialEq, Group)] // How could I derive Group here as well?
struct AGroup<G: Group>(G);

without all this boilerplate:

impl<G: Group> Add for AGroup<G>{
    type Output = AGroup<G>;
    fn add(self, other: Self) -> Self {
        AGroup(self.0 + other.0)
    }
}

impl<G: Group> Neg for AGroup<G>{
    type Output = AGroup<G>;
    fn neg(self) -> Self {
        AGroup(-self.0)
    }
}
...

I dont know if it is good practice, but you could implement deref, https://doc.rust-lang.org/std/ops/trait.Deref.html — Netwave, Mar 09 '21 at 10:55
Do you want to result of adding `Group`'s to always return an `AGroup`? — WBuck, Mar 09 '21 at 13:07
I just realized I have been assuming `Group` looks something like `trait Group: Add + Neg + ... {}` (to make the boilerplate make sense). If that is so, please add that to the answer; if `Group` is substantially different from that, please indicate how, so I can make sure my answer is correct. Thanks! — trent, Mar 09 '21 at 16:19

score 1 · Answer 1 · answered Mar 09 '21 at 14:08

You could also just create a method exposing the inner object interface:

pub trait Group {
    fn foo(self: &Self){
        println!("Called from group")
    }
}

#[derive (Copy, Debug, Clone, Eq, PartialEq)] // How could I derive Group here as well?
pub struct AGroup<G: Group>(G);

impl<G: Group> AGroup<G> {
    pub fn inner(&self) -> &impl Group {
        &self.0
    }
}

pub struct Test {}
impl Group for Test {}



fn main( ) {
    let a = AGroup( Test {} );
    a.inner().foo();
}

Playground

trent · Answer 2 · 2021-03-09T16:12:45.280

It's not possible in Rust today (as of 1.50) or for the foreseeable future.

You could write a custom derive macro for Group. This amounts to writing code that generates the boilerplate, instead of writing the boilerplate itself. It might be worthwhile if you're going to put #[derive(Group)] on multiple types. But if you only want automatic implementations for AGroup<G>, it'll probably be much shorter and simpler just to write the boilerplate.

The name of the feature you really want is "delegation". It's been RFCed a couple of times but never accepted (IMO both RFCs have tried to cover too many different use cases and turned out unwieldy). There are concerns about what syntax is the best, how granular delegation should be, and how easily it might be abused to create brittle "inheritance-like" relationships between data structures.

For now, if you cannot find a different design that doesn't require delegation (such as that suggested in Netwave's answer), you should probably bite the bullet and write the delegating impls yourself. There are crates such as delegate and ambassador that can make certain delegation patterns easier, but I'm not sure if either of them exactly fit what you're trying to do (more evidence that everybody wants a slightly different form of "delegation").

Rust traits on newtypes

2 Answers2

Related questions