YouTipRust Macros
# Rust Macros
Rust macros are a powerful tool for generating code at compile time, allowing you to create custom syntax extensions when writing code.
Macros are a metaprogramming technique in code that allows generating code at compile time. Macros can help simplify code, improve readability and maintainability, and allow developers to perform code generation operations at compile time.
There are two types of macros in Rust: Declarative Macros and Procedural Macros.
This article mainly introduces declarative macros.
### Macro Definition
In Rust, the `macro_rules!` keyword is used to define declarative macros.
macro_rules! my_macro { // Pattern matching and expansion ($arg:expr) => { // Generated code // Use $arg to replace the matched expression };}
Declarative macros are defined using the `macro_rules!` keyword, and they are called **"macro_rules"** macros. These macros are based on pattern matching, which can match code structures and generate corresponding code based on the matched patterns. Such macros can be used to simplify some common code patterns without introducing new syntax structures.
Here is a simple example of macro definition:
## Example
// Macro definition
macro_rules! greet {
// Pattern matching
($name:expr)=>{
// Macro expansion
println!("Hello, {}!", $name);
};
}
fn main(){
// Call the macro
greet!("World");
}
**Explanation**
* **Pattern Matching:** Macros match code fragments passed to them through pattern matching. Patterns are the left side of macro rules, used to capture different code structures.
* **Rules:** Macro rules are a set of patterns guided by `$` and corresponding expansion code, separated by semicolons.
* **Macro Expansion:** When a macro is called, the matched pattern is replaced with the corresponding expansion code. The expansion code is the right side of the macro rule.
### Example
Here is a more complex example demonstrating how to use a macro to create a simple `vec!` macro for more convenient Vec creation:
## Example
// Macro definition
macro_rules! vec {
// Base case, empty case
()=>{
Vec::new()
};
// Recursive case, with elements
($($element:expr),+ $(,)?)=>{
{
let mut temp_vec = Vec::new();
$(
temp_vec.push($element);
)+
temp_vec
}
};
}
fn main(){
// Call the macro
let my_vec = vec![1,2,3];
println!("{:?}", my_vec);// Output: [1, 2, 3]
let empty_vec = vec![];
println!("{:?}", empty_vec);// Output: []
}
In this example, the `vec!` macro uses pattern matching and syntax like `$($element:expr),+ $(,)?)` to capture elements passed to the macro and create a Vec with them.
Note that `$(,)?)` is used to handle trailing commas, allowing it to work properly in different usage scenarios.
* * *
## Procedural Macros
Procedural macros are more flexible and powerful macros that allow manipulating the Abstract Syntax Tree (AST) through custom code generation processes at compile time. Procedural macros are functionally closer to functions, but they are more complex to write and use.
Types of procedural macros:
* **Derive Macros**: Macros used to automatically implement traits (such as `Copy`, `Debug`).
* **Attribute Macros**: Used to attach additional metadata to declarations, such as `#[derive(Debug)]`.
Implementing procedural macros usually requires using functionality provided by the `proc_macro` crate, such as `TokenStream` and `TokenTree`, to more directly manipulate source code.