Can macros match against constant arguments instea

Question

Given the macro matching example, this shows how macros can match an argument.

I've made very minor changes here to use numbers:

macro_rules! foo {
    (0 => $e:expr) => (println!("mode X: {}", $e));
    (1 => $e:expr) => (println!("mode Y: {}", $e));
}

fn main() {
    foo!(1 => 3);
}

Works, printing: mode Y: 3

However I would like to use a constant as an argument, can this be made to work:

const CONST: usize = 1;

macro_rules! foo {
    (0 => $e:expr) => (println!("mode X: {}", $e));
    (1 => $e:expr) => (println!("mode Y: {}", $e));
}

fn main() {
    foo!(CONST => 3);
}

Is this possible in Rust?

---

Note, using a regular match statement isn't usable for me, since in my code each branch resolves to different types, giving an error. So I'm specifically interested to know if a constant can be passed to a macro.

Answer 1

I'm fairly sure the answer is "no"; at macro expansion time all you have are token trees - expansion happens before evaluation, or even type inference/checking.

Answer 2

No.

Macros operate on the Abstract Syntax Tree, so they reason at the syntactic level: they reason about tokens and their spelling.

For example:

fn main() {
    let v = 3;
}

In this case, the AST will look something like:

fn main
    \_ let-binding v
        \_ literal 3

If you ask a macro whether v is 3, it will look at you funny, and wonder why you would try comparing a variable name and a literal.