Rust Macros

Written
  • Useful Links
  • 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.

Thanks for reading! If you have any questions or comments, please send me a note on Twitter. And if you enjoyed this, I also have a newsletter where I sometimes write about tech thoughts, interesting things I've read, and project updates.

You can check out a recent issue, or enter your email below to subscribe.