Suggestion: Shorter attribute name than target_method about rust-delegate HOT 5 CLOSED

I changed it to use and I like how it reads, but if I'm not missing anything it seems that it cannot actually be used, because it's an actual keyword and when I parse the attribute, it expects a path after use and therefore I cannot use it as use(name). Unless we want to write something like r#use :-)

call doesn't have this problem, since it's not a keyword and I think that it's more explicit, even though we actually generate #[inline(always)] by default, so the call might only be there at compile time :)

Also when the user specifies inline manually, like this:

#[inline(always)]
#[call(method)]
...

it reads a bit weird, but it's a small detail I suppose.

Another thing that came up is wrap, but it doesn't have a well established meaning in this crate (and in general it's a very overloaded term), so that's probably worse than call.

from rust-delegate.

I like as, but I see two problems with it:

1. In my opinion the name as implies that it will generate code like this:

#[as(len)]
pub fn size(&self) -> usize;
v
pub fn len(&self) -> usize { self.inner.size() }

But in the current implementation, the renaming order is reversed, i.e. it would actually generate this:

pub fn size(&self) -> usize { self.inner.len() }

I looked at the implementation briefly and it's much easier for me to change the name in this direction. I will try to modify it so that I could also use the other direction, but I'm not sure if it's possible to do so easily.

2. When the user writes pub fn size(&self) -> usize;, I think that it is more natural that the actual method will have exactly this signature, i.e. I think it's better if the attribute changes the underlying method call and not the signature. as sounds like you are changing the signature (export this function as len).

If we keep the current implementation, we have to use a name that obviously changes the called method and not the signature. call(len) or use(len) seem like good alternatives to me.

from rust-delegate.

@Kobzol
Yes, I agree, I did not mean to suggest swapping the order of the callee and caller (and I don't think we should support this swapping in any way, to avoid confusion).
I also agree that as could be misinterpreted to mean that.
Actually, I hadn't thought of use(len), but it looks like the best option to me! :)

from rust-delegate.

What about target or using 🤔 it’s a few characters more but I honestly don’t think that difference would matter

from rust-delegate.

I think call is a good choice!

from rust-delegate.