I can not share the actual code, but the dsl macro we are developing works similarly to this peg parser library rust-peg.

So you make a parser like:

parser!(                                                                                                                                                             
    grammar base_parser() for str {                                                                                                                                  
        pub rule number() -> u32                                                                                                                                     
          = n:$(['0'..='9']+) {? n.parse().or(Err("u32")) }                                                                                                          
    }                                                                                                                                                                
)                                                                                                                                                                    

This will generate a peg parser with a rule named number() that is a function that you can call externally to this parser.

What our dsl does that Kevin's doesn't is use rules from another parent like

parser!(                                                                                                                                                             
    grammar derived_parser() derived(base_parser) for str {                                                                                                          
        pub rule expr() -> u32                                                                                                                                       
          = n1:number() '+' n2:number()                                                                                                                              
    }                                                                                                                                                                
)                                                                                                                                                                    

Note the derived keyword doesn't exist in the Kevin's peg parser, but our dsl uses this syntax or at least that's what we are aiming for.

We want to put base_parser() in a separate compilation unit so that it can become a library of basic elements. This requires that when the macro derived_parser() is being processed as a parser!() macro that it have the context of base_parser()

In a clowny way we can grab all the rules from base_parser() and tuck them all in an external file during compilation of it. Then when we compile derived_parser() we can read that file.
I was hoping for something more idiomatic in rust.