Macro hygiene only for expressions/variables but not for types?

[jbe]

Continuing the discussion from Helper closures which modify a state: Use RefCell or pass mutable references?:

@semicoleon

You can also use macros

fn main() {
    let mut sum = 0;
    macro_rules! add {
        ($addend:expr) => {
            sum += $addend
        };
    }
    /* … */

(Playground)

Hmmm, I tried that too, but my naive approach didn't work at first (see Playground here).

I worked with macros previously which require a certain type to be in scope with a certain name, see radiorust::flt! or argmin::float! as two examples.

To give another example:

// We can define this macro outside `foo`:
macro_rules! works_on_type_T {
    () => { println!("{:?}", ::std::mem::size_of::<T>()); };
}

fn foo<T>(v: i32) {
    // But we must define this macro inside `foo`:
    macro_rules! works_on_variable_v {
        () => { println!("{:?}", ::std::mem::size_of_val(&v)); };
    }
    works_on_type_T!();
    works_on_variable_v!();
}

fn main() {
    foo::<u8>(12i32);
}

(Playground)

Why can I define works_on_type_T! outside foo (where T is not in scope) while works_on_variable_v! must be defined inside foo (where v is in scope).

Is this behavior intended? Why? Will it stay like this in future?

[semicoleon]

This came up recently here as well

Where to learn the precise kind of hygiene that Rust macros provide

I'm trying to understand precisely what sort of hygienic macros are provided by Rust. The reason I'm asking this question is that a search thru the literature, e.g. Clinge&Wand ( https://dl.acm.org/doi/10.1145/3386330 ) would indicate that there's been a TON of work in this area over the decades, and so, well, if one is to have a good idea of what Rust does, it had better be precise. I know I can RTSC, and I intend to do that if nothing else works, but I figured I'd ask if there's some precise…

Here's an excerpt from The Little Book of Rust Macros linked in that thread

macro_rules! macros in Rust are partially hygienic, also called mixed hygiene. Specifically, they are hygienic when it comes to local variables, labels and $crate, but nothing else.

My understanding is that it is intentional, but that it isn't necessarily going to be how macros work in declarative macros 2.0 (aka macro aka decl_macro aka macros-by-example). But also a lot of things are still up in the air on that feature so take that with a grain of salt.