implement trait delegation delegatable_trait and delegate_trait(target=field)

[HuStmpHrrr]

see the new added test for an example use.

I added two macros, #[delegatable_trait] and #[delegate_trait]. #[delegatable_trait] tags trait, the impl of which can be applied #[delegate_trait]. For an impl of a tagged trait, #[delegate_trait(target=X)] delegates all unimplemented required functions to self.X.f(...). In particular, if a function has a default body, the function it kept as is, and not delegated. This behavior mimics inheritance in OOP.

[Kobzol]

Hi, could you say a bit more about your use-case that you're trying to solve here? rust-delegate is designed for delegation that can be done in an unobtrusive way without having to annotate traits. For this other approach, https://crates.io/crates/ambassador or https://docs.rs/delegation/latest/delegation/ is likely a better approach.

[HuStmpHrrr]

Hi, I think ambassador is somewhat similar but still not doing what I want. delegation has gone to far for my taste. I am looking for something that is closer to OOP. I am trying to do overriding. In other words, I would like to only delegate the unspecified, required functions, by only specifying what I would like to override. It's like classes in OOP, only overridden functions are changed. other functions are untouched. at this moment, no crate does what I want.

for my actual application, please see this trait

https://github.com/yaspar-org/yaspar-ir/blob/5d0c8c78bccb1366be2d261ccbd033513ba2afd2/src/raw/alg/rec.rs#L81

this trait is very long, but really most cases are trivial. I bumped into delegate last week and created this PR: https://github.com/yaspar-org/yaspar-ir/pull/63/changes

I figured that delegate can do a stretch. if you think this is not the right solution, I am all ears though.

[Kobzol]

The implementation needs to have some way of referring to the delegated trait; using just its name does not work in general, e.g.:

mod foo {
    use delegate::delegatable_trait;

    #[delegatable_trait]
    pub trait Greet {
        fn hello(&self) -> String;
        fn hello2(&self) -> String;
        fn goodbye(&self) -> String;
    }
}

use foo::Greet as Greet2;

breaks.

I examined how the macro works, and I think that this is quite far from what rust-delegate does, and is more about overriding trait implementations than delegation. Maybe it would make sense as a separate crate.