Is it possible to write a Rust macro that will exp

问题:

I would love to be able to something like the following:

macro_rules! impl_a_method(
    ($obj:ident, $body:block) => (
        fn a_method(foo: Foo, bar: Bar, baz: Baz) -> $obj $body
    )
)

// Implementation would look like:

impl_a_method!(MyType, {
    MyType {
        foo: foo.blah(),
        bar: bar.bloo(),
        baz: baz.floozy(),
    }
})

My real-world example features methods with much larger signatures which I have to implement in unique ways for 30+ different types.

I have tried something similar to the above macro, however I run into errors where rustc considers foo, bar and baz unresolved names at the expansion site (even though I'm sure the macro declaration lexically precedes the use).

Is it possible to do something like this?

If not, can you recommend an approach that would achieve something similar?

回答1:

That's not possible due to macro hygiene. Any identifier introduced in the macro body is guaranteed to be different from any identifier at the macro call site. You have to provide all identifiers yourself, which somewhat defies the purpose of the macro:

impl_a_method!(MyType, (foo, bar, baz), {
    MyType {
        foo: foo.blah(),
        bar: bar.bloo(),
        baz: baz.floozy(),
    }
})

This is done by this macro:

macro_rules! impl_a_method(
    ($obj:ty, ($_foo:ident, $_bar:ident, $_baz:ident), $body:expr) => (
        fn a_method($_foo: Foo, $_bar: Bar, $_baz: Baz) -> $obj { $body }
    )
)

The only thing you're really saving here is writing types of method parameters.