Rust Macros

Written 2021-09-15 — Updated 2023-02-10

Useful Links
- https://danielkeep.github.io/tlborm/book is a useful source of info
- https://github.com/dtolnay/proc-macro-workshop
Arguments
- Macro argument types
  - expr - Any expression
  - ident - An identifier
  - path - A module path
  - ty - A type
  - item - A top level item (use, struct Something{}, etc.)
  - tt - Any token tree
  - block - A code block in brackets
- Argument patterns can have * or + added to it to indicate repetition.
  - ```
  macro_rules! macro {
    ($an_arg: expr, $($num: expr),*) => { 
      let mut x = get_number($an_arg);	
      $(
        x += $num;
   	)* // Wrapping it like this expands the variadic arguments
   	x
    }
  }
```
Nested macros
- Macros normally can't call each other if one of the macros is used from another module.
- But you can create another macro rule in the same macro. Traditionally these rules start with @ to reduce chances of accidentally triggering the rule.
- ```
macro_rules! macro1 {
  () => { macro1!(@macro2)};
  (@macro2) => { the nested macro }
}
```
Dealing with tokens
- The paste crate lets you concatenate multiple identifiers into a new identifier, which is difficult to do in normal macros.
Proc Macros
- These are more powerful and are written in Rust.
- They can be function-like macros as with macro_rules! or attribute macros like #[test], or derive macros to work with #[derive(...)].
- Since these are effectively compiler plugins, they have to be in a separate crate from the one that uses the macro.
- Useful Crates
  - syn helps with parsing Rust source.