Macros

Macros are used in programming to automate repetitive tasks and simplify code maintenance. They are essentially small scripts or snippets of code that are defined once and can be reused multiple times throughout a program.

Use cases for macros:

  1. Code abstraction and simplification: Macros allow programmers to create short, easy-to-understand names for complex or repetitive code snippets. For example, instead of writing a long calculation formula multiple times, a macro can be defined to encapsulate the formula using a simple name. This enhances code readability and reduces the chances of errors.
  2. Code generation: Macros can generate code dynamically at compile time. This is particularly useful for generating repetitive code or code that needs to be generated based on certain conditions. For instance, a macro can be defined to create different versions of a function based on the input argument type or compile-time flags.

Rust

Macros in Rust allows for definition and generation of custom syntax extensions. They enhance the language by enabling the creation of new constructs, abstractions, and domain-specific languages (DSLs) specific to the needs of each project.

Defining a Macro

Macros are defined using the macro_rules! keyword or the more powerful #[macro_export] attribute. The macro_rules! macro is more commonly used as it introduces macro patterns and the associated expansion. It is defined at the module level and starts with the keyword macro_rules! followed by the macro's name and the pattern to match. 

macro_rules! my_macro {
    // pattern and associated expansion
    // ...
}

Writing Macro Patterns

Macro patterns are used to match specific syntax in the code. These patterns consist of tokens and patterns that can also contain literal values or identifiers. Tokens are usually encased in $() or $( ... ) to distinguish them from regular code. 

macro_rules! my_macro {
    () => {
        // expansion when the pattern is matched
        // ...
    };
    ($x:expr) => {
        // expansion when a single expression is provided
        // ...
    };
    ($x:expr, $y:expr) => {
        // expansion when two expressions are provided
        // ...
    };
}

Expanding the Macro

Once the macro is defined, it can be expanded in the code by using its name followed by !. The code within the macro invocation will be matched against the defined patterns, and the corresponding expansion will be executed. 

let result = my_macro!(); // expands to the first pattern

let result = my_macro!(42); // expands to the second pattern

let result = my_macro!(10, 20); // expands to the third pattern

Building Code using Macros

Macros can generate complex code and transformations. They can contain blocks, expressions, statements, or even generate multiple items, such as functions, structs, etc. Macros are called during the code compilation process and can analyze, transform, and generate new code based on the provided input. 

macro_rules! generate_struct {
    ($name:ident { $($field:ident: $type:ty),* }) => {
        struct $name {
            $($field: $type),*
        }
    };
}

generate_struct!(Person {
    name: String,
    age: u32,
});

Importing Macros

Macros can be defined in the same module or be imported from other modules using the use keyword. Importing macros allows their usage in other modules or even in other crates when the macro is marked with #[macro_export]. 

mod my_macros {
    #[macro_export]
    macro_rules! my_macro {
        // pattern and associated expansion
        // ...
    }
}

use my_macros::my_macro;

fn main() {
    my_macro!(); // expansion of imported macro
}

Rust's macro system is extensive and allows for including complex pattern matching, repetition, recursion, hygiene, and procedural macros.

println

Use the println macro to print to print a line. 

let x = 5;
let y = 10;

println!("x = {x} and y + 2 = {}", y + 2);