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, doc.rust-lang.org/std/ops/trait.Deref.html — Netwave
– Netwave, Commented Mar 9, 2021 at 10:55
Do you want to result of adding Group's to always return an AGroup? — WBuck
– WBuck, Commented Mar 9, 2021 at 13:07
I just realized I have been assuming Group looks something like trait Group: Add<Output=Self> + Neg<Output = Self> + ... {} (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
– trent, Commented Mar 9, 2021 at 16:19
Rel: Automatically implement traits of enclosed type for Rust newtypes (tuple structs with one field) — cafce25
– cafce25, Commented Sep 19, 2023 at 6:14

trent · Accepted Answer · 2021-03-09 16:12:45Z

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").

Related questions

On implementing Deref, which is occasionally suggested as an alternative to delegation:

Just wanted to add that nothing has changed in the meantime, there is still no delegation possible in Rust 1.72 and as far as I'm aware there are also no new RFCs for it.

Netwave · Accepted Answer · 2021-03-09 14:08:40Z

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

Collectives™ on Stack Overflow

Rust traits on newtypes

2 Answers 2

Related questions

1 Comment

Comments

Linked

Hot Network Questions