وحدات الماكرو التصريحية (`macro_rules!`)

Macros are a way to write code that writes code! They're like functions, but they operate on syntax trees (the structure of your code) instead of values.

• They help abstract repetitive code.
• They enable Domain Specific Languages (DSLs) within Rust.
• They run at compile time, expanding into regular Rust code before compilation.

Rust's declarative macros use the macro_rules! keyword. They define a set of rules that match specific patterns of Rust code.

Think of it as pattern matching for code snippets. When the compiler sees a macro invocation, it tries to match the input to one of the rules you've defined.

Let's create a very simple macro that prints a greeting. Notice the macro_rules! keyword and the () => {} syntax, defining a rule with no input pattern.

Try running this example:

Macros can take input using "designators." These tell the macro what kind of Rust syntax it should expect to capture.

• $expr: An expression (e.g., 1 + 2, "hello")
• $ident: An identifier (e.g., variable name, function name)
• $ty: A type (e.g., i32, String)
• $block: A block of code (e.g., { ... })
• ...and many more!

Here's a macro that takes an expression ($e:expr) and prints its value. The :expr is the designator.

The captured $e then becomes available for use in the macro's body. The stringify! macro converts the expression into its string representation.

What if you want a macro to take multiple arguments of the same type? You can use repetition operators: $()*.

• $(): The content inside is the pattern to repeat.
• *: Zero or more repetitions.
• +: One or more repetitions.
• You can also specify a separator, like $(...),* for comma-separated items.

Let's create a macro that takes multiple expressions, separated by commas, and prints each one individually. This is powerful for creating list-like structures.

Rust's macros are "hygienic." This means that variables defined inside a macro won't accidentally clash with variables outside the macro, even if they have the same name.

The compiler renames things internally during expansion to prevent unintended side effects, making macros safer and more predictable to use.

Sometimes macros don't expand as you expect. Rust provides a way to see the expanded code:

• Run cargo expand (requires installing the cargo-expand tool)
• Use rustc --pretty expanded directly on your source file.

This shows you the raw Rust code that your macro generates, which is invaluable for debugging and understanding complex macro behavior!

Consider the following macro definition:

macro_rules! make_tuple {
    ( $x:expr, $y:expr ) => {
        ($x, $y)
    };
}

Which of the following lines would successfully compile and use the make_tuple! macro?

In this lesson, you learned about declarative macros using macro_rules!:

• They generate code at compile time, abstracting repetitive patterns.
• They use pattern matching to capture input based on syntax.
• Designators like $expr, $ident specify what kind of syntax to expect.
• Repetition operators like $()* handle multiple arguments with flexible separators.
• Macros are hygienic, preventing accidental name conflicts.

Macros are a powerful tool for reducing boilerplate and creating flexible, ergonomic APIs in Rust!