What are Macros in Rust?

by
Previous
Next

In Rust, macros are tools that allow you to write code that writes other code. This helps you to avoid repeating the same patterns over and over, and makes your code reusable and flexible.

Macros are expanded at compile time, meaning the compiler generates the actual code before the program runs. This can make them faster and more powerful for certain tasks like logging, testing, or implementing traits for multiple types.

Types of Macros in Rust:

1) Declarative Macros (macro_rules!): This is the most common type that we define patterns and the code the macro should generate.

2) Procedural Macros: These are the custom macros that can take code as input and produce new code. It’s useful for more complex transformations.

3) Attribute Macros: They modify or annotate existing code. For example, #[derive(Debug)] automatically implements the Debug trait for a struct or enum.

Declarative Macros (macro_rules!)

Declarative macros are the most common macros. They allow you to define patterns that expand into code automatically.

Syntax of macro_rules!

macro_rules! macro_name {
    (pattern) => {
        generated_code
    };
}

In this code:

  • macro_name! → This is the name of the macro.
  • (pattern) → The “trigger” or pattern that the macro matches.
  • generated_code → The code that Rust inserts wherever the macro is used.

Example: A Simple Macro

macro_rules! greet {
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
}

fn main() {
    greet!("Alice");  // Expands to println!("Hello, Alice!");
    greet!("Bob");    // Expands to println!("Hello, Bob!");
}

Explanation:

  • $name:expr → Captures an expression passed to the macro.
  • Each time, greet! is called, it generates a println! statement with the given name.

Example: Macro with Arguments

For example:

macro_rules! sum_and_print {
    ($x:expr, $y:expr) => {
        println!("The sum is: {}", $x + $y);
    };
}

fn main() {
    sum_and_print!(7, 8);  // Expands to println!("The sum is: {}", 7 + 8)
    sum_and_print!(20, 30); // Expands to println!("The sum is: {}", 50)
}

Explanation:

  • $x:expr and $y:expr capture any valid Rust expressions you provide as arguments.
  • $x + $y → The macro generates code that adds the two values.

Example: Macro with Multiple Patterns

Macros in Rust can be designed to handle different kinds of input. This allows a single macro to respond differently based on what you give it. For example:

macro_rules! input_response {
    (yes) => {
        println!("You said yes!");
    };
    (no) => {
        println!("You said no!");
    };
    ($val:expr) => {
        println!("You entered: {}", $val);
    };
}

fn main() {
    input_response!(yes);     // Prints: You said yes!
    input_response!(no);      // Prints: You said no!
    input_response!(100);     // Prints: You entered: 100
}

Procedural Macros In Rust

Procedural macros are advanced macros that allow you to manipulate Rust code at the compiler level. Procedural macros take Rust code as input, process it, and produce new code.

These macros are especially useful when you want to automate repetitive code patterns or implement custom behaviors for structs, enums, or functions.

Types of Procedural Macros:

  1. Custom Derive Macros: It allows you to automatically generate code for structs or enums. Example: #[derive(Debug)] automatically implements the Debug trait.
  2. Attribute Macros: This is the modification or annotation of code items like functions or modules.
  3. Function-Like Macros: They look like function calls but generate code at compile time.

Example: Custom Derive Macro

A custom derive macro allows you to automatically add behavior to a struct or enum.

  1. Add the following to your Cargo.toml:
[dependencies]
proc-macro = "1.0"
  1. Create the procedural macro in a library crate:
extern crate proc_macro;

use proc_macro::TokenStream;

#[proc_macro_derive(MyTrait)]
pub fn my_trait_derive(input: TokenStream) -> TokenStream {
    // Parse the input and generate code here
    input
}
  1. Use it in another crate:
#[derive(MyTrait)]
struct Example;

Attribute Macros

Attribute macros are used to annotate or modify code. For example:

#[derive(Debug)]
struct MyStruct {
    name: String,
    age: u32,
}

fn main() {
    let person = MyStruct {
        name: String::from("Alice"),
        age: 30,
    };
    println!("{:?}", person);
}

Explanation:

  • #[derive(Debug)]: Automatically generates the Debug implementation for MyStruct.

Advantages of Rust Macros

  1. Compile-Time Efficiency: Macros are expanded at compile time, ensuring zero runtime cost.
  2. Flexibility: Handle repetitive tasks, reducing boilerplate code.
  3. Customizability: Create your own macros to suit specific needs.

Learn Other Topics About Rust

Previous
Next

Leave a Comment