Higher order macros

Question

Is it possible in rust to write a macro that creates other macros. For example, suppose I define the following two macros:

macro_rules! myprint(
    ($a:expr) => (print!("{}", $a))
)

macro_rules! myprintln(
    ($a:expr) => (println!("{}", $a))
)

Since the two macros repeat a lot of code, I may want to write a macro to generate the macros.

I've tried to generate such a meta macro.

#![feature(macro_rules)]

macro_rules! metamacro(
    ($i:ident) => (
        macro_rules! $i (
            ($a:expr) => ({println!("hello {}", $a)})
        )
    );
)

metamacro!(foo)

fn main() {
    foo!(1i);
}

but get the following errors:

<anon>:6:13: 6:14 error: unknown macro variable `a`
<anon>:6             ($a:expr) => ({println!("hello {}", $a)})
                     ^
playpen: application terminated with error code 101
Program ended.

Edit: After playing around with the macros some more, I discovered that a higher order macro works as expected if the returned macro doesn't receive any arguments. For example, the following code

#![feature(macro_rules)]

macro_rules! metamacro(
    ($i:ident) => (
        macro_rules! $i (
            () => ({println!("hello")})
        )
    );
)

metamacro!(foo)

fn main() {
    foo!();
}

prints hello

Answer 1

This was recently made possible in #34925. The answer below refers to older versions of Rust.

---

This is #6795 and #6994, and isn't directly possible at the moment. E.g. the first thing one would try is

#![feature(macro_rules)]

macro_rules! define {
    ($name: ident, $other: ident) => {
        macro_rules! $name {
            ($e: expr) => {
                $other!("{}", $e)
            }
        }
    }
}

define!{myprintln, println}
define!{myprint, print}

fn main() {}

But this fails with

so8.rs:6:13: 6:14 error: unknown macro variable `e`
so8.rs:6             ($e: expr) => {
                     ^

(Filed #15640 about the caret pointing at the ( instead of the $e.)

The reason is macro expansion is "dumb": it naively interprets and replaces all the tokens, even inside nested macro invocations (and macro_rules! is a macro invocation). Hence, it can't tell that the $e inside the interior macro_rules! are actually meant to be left as $e: it's just trying to replace them when expanding define.

The second thing one might try is passing in extra arguments to define to place in the interior definition, so that the $e doesn't appear directly in the nested invocation:

#![feature(macro_rules)]

macro_rules! define {
    ($name: ident, $other: ident, $($interior: tt)*) => {
        macro_rules! $name {
            ($($interior)*: expr) => {
                $other!("{}", $($interior)*)
            }
        }
    }
}

define!{myprintln, println, $e}
define!{myprint, print, $e}

fn main() {}

That is, I added the $interior: tt to allow capturing the $e. tt stands for token tree, which is a non-delimiter raw token (e.g. $ or some_ident) or a sequence of tokens surrounded by matching delimiters (e.g. (foo + bar fn "baz")). Unfortunately, it seems expansion is eager enough for the $e expansion to be expanded too:

so8.rs:8:13: 8:14 error: unknown macro variable `e`
so8.rs:8             ($($interior)*: expr) => {
                     ^

It works fine when the nested macro has no argument itself, because there is no nested $... non-terminals and so the expansion phase doesn't ever hit the definition problem described above.

---

Lastly, you can get some semblance of code sharing since you can expand to macro invocations by name:

#![feature(macro_rules)]

macro_rules! my {
    ($name: ident, $e: expr) => {
        $name!("{}", $e)
    }
}

fn main() {
    my!(print, 1i);
    my!(println, 2i);
}

which prints 12.

Answer 2

Here is one example that works, perhaps a starting point for you:

#![feature(macro_rules)]

macro_rules! metamacro(
    ($i:ident) => (
        macro_rules! $i (
            () => ({println!("hello!")})
        )
    );
)

metamacro!(hello)

fn main() {
    hello!();
}