Call macro inside macro repetition

Well, I'm trying to achieve nothing more that stated in the title:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=2cacd8ce561af93ceabd40b123b6549a

I've seen examples of how a macro called inside another macro, but in repetition for some reason in doesn't expand, is it possible to achieve that?

The problem you're running into is that a macro expansion needs to produce valid rust code, and only then will any macros in the emitted code be expanded. As written, outer! expands to this, which is ungrammatical from Rust's point of view:

enum Test {
    A inner!(ok),
    B inner!(ok)
}
2 Likes

Thank you for the response.
How can I achieve modularity for this case? Like having a body for a variant and process it with another macro to have valid rust code only after this stage?

To do this kind of thing, you need what's known as a tt-muncher macro: It builds all of the text for the enum body first, and then wraps it in the enum as the final step. A good reference for this kind of advanced macro programming is The Little Book of Rust Macros.

macro_rules! inner {
    ( $name:ident {$($body:tt)*} ($variant:ident) $($tail:tt)* ) => {
        inner!{
            $name // Enum name
            {
                $($body)*  // Previously-built variants
                $variant,  // What this variant should look like
            }
            $($tail)* // Unprocessed variants
        }
    };
    
    // When there are no more variants, emit the enum definition
    ( $name:ident {$($body:tt)*} ) => {
        enum $name { $($body)* }
    };
}

macro_rules! outer {
    ( $($variants:ident),* ) => {
        inner!{ Test {} $(($variants))* }
    }
}

(Playground)

1 Like

Thanks,
I believe other questions would be offtopic, and the main takeaway is to keep valid syntax on each step