How to define some macros as 'private' to a module, when using `macro_use` in Rust?

Question

I have a file which contains shared macros for a Rust project.

Since I want to re-use the macros across the crate (between modules), I declare the module with #[macro_use].

While writing the macros, I split out some shared logic into a macro to avoid repetition, in this case I can't use a private function, it needs to be a macro. If possible, I'd like to hide this shared macro so it can't be used directly by other modules.

Is there a way to make some macros private, so they aren't exposed to other modules in the same crate via #[macro_use]?

Answer 1

There actually is an idiom in Rust, to hide away "implementation-detail" macros.

Rather than declaring a separate macros, you can instead declare a separate case within the existing macro. The examples I've seen would use the impl keyword for this, and the impl cases are located at the bottom of the macro definition.

Thus, instead of:

macro_rules! hello_impl {
    ($name:expr) => {
        println!("Hello {}!", $name);
    }
}

macro_rules! hello_world {
    () => {
        hello_impl!("world");
    }
}

You use:

macro_rules! hello_world {
    () => {
        hello_world!(impl "world");
    },
    (impl $name:expr) => {
        println!("Hello {}!", $name);
    }
}

This way, there is no implementation macro any longer; and you only have one macro to export.