Must Know Rust Macros for beginners

Macros are a powerful feature in Rust, and learning to use them effectively can significantly enhance your productivity. Here are some commonly used and helpful macros for Rust beginners:

println! and format! Macros:

println! is used for printing to the console with formatting.
format! is used to create formatted strings.

let name = "Alice";
let age = 30;
println!("Hello, {}! You are {} years old.", name, age);

let formatted_string = format!("{} + {} = {}", 2, 3, 2 + 3);
println!("Formatted string: {}", formatted_string);

vec! Macro:
- Used to create a Vec<T> easily.
```
let numbers = vec![1, 2, 3, 4, 5];
```

vec! Macro with Repetition:

Create a vector with repeated elements.

let zeros = vec![0; 5]; // Creates a vector with five zeros: [0, 0, 0, 0, 0]

vec! with Pattern Matching:

Create a vector with pattern matching.

let values = vec![
    Some(1),
    Some(2),
    None,
    Some(3),
];

assert! and assert_eq! Macros:

Used for testing and asserting conditions.

assert!(x > 0, "x must be positive");
assert_eq!(result, expected_result, "Result is not as expected");

cfg! Macro:

Conditional compilation based on configuration flags.

#[cfg(feature = "debug")]
fn debug_function() {
    // Implementation for debug build
}

dbg! Macro:
- A simple debugging macro for printing values.
```
let x = 42;
dbg!(x);
```
env! Macro:
- Retrieve environment variables at compile time.
```
let api_key = env!("API_KEY");
```
include_str! and include_bytes! Macros:
- Include the content of a file as a string or bytes during compile time.
```
let content_str = include_str!("file.txt");
let content_bytes = include_bytes!("file.bin");
```
panic! Macro:
- Abort the program with a panic message.
```
panic!("Something went terribly wrong!");
```

cfg_attr! Macro:

Allows applying attributes conditionally based on configuration flags.

#[cfg_attr(debug_assertions, allow(dead_code))]
fn conditional_dead_code() {
    // Function body
}

match! Macro:
- A concise and convenient way to perform pattern matching in expressions.
```
let result = match!(some_value, Some(x) if x > 0 => x, _ => 0);
```

try! Macro (now replaced by ?):

Used for early returns in functions that return Result or Option. It’s now deprecated in favor of the ? operator.

fn example() -> Result<(), MyError> {
    let result = try!(some_function());
    // Rest of the function
    Ok(result)
}

concat! Macro:

Concatenates string literals at compile time.

const MESSAGE: &str = concat!("Hello", ", ", "world!");

file! and line! Macros:
- Returns the current file path and line number at compile time.
```
println!("File: {}, Line: {}", file!(), line!());
```

stringify! Macro:

Converts Rust source code into a string.

let code_str = stringify! {
    fn my_function() {
        println!("Hello, world!");
    }
};

include! Macro:
- Dynamically includes the content of a file during compilation.
```
let included_code: &str = include!("some_file.rs");
```
format_args! Macro:
- Constructs a std::fmt::Arguments structure for deferred formatting.
```
let formatted_args = format_args!("{} + {} = {}", 2, 3, 2 + 3);
```

global_asm! Macro:

Inline assembly code at the global scope.

global_asm!(
    ".section .data\n\
     my_global: .asciz \"Hello, world!\\n\""
);

env! Macro with Default Value:
- Retrieve an environment variable with a default value.
```
let api_key = env!("API_KEY", default = "default_key");
```
todo!() Macro:
- Marks a piece of code as unfinished or something that needs to be implemented. It’s useful as a placeholder to indicate work that still needs to be done.
```
fn example() {
    // TODO: Implement this function
    todo!();
}
```
unimplemented!() Macro:
- Marks a piece of code as unimplemented. It’s similar to todo!() but provides more explicit signaling that the functionality is intentionally not implemented.
```
fn example() {
    // Unimplemented: This feature is not yet implemented
    unimplemented!();
}
```
unreachable!() Macro:
- Marks a code path as unreachable. It’s used to indicate that the code should never be executed. If the code does get executed, it will panic.
```
fn example(x: Option<i32>) -> i32 {
    match x {
        Some(value) => value,
        None => unreachable!(),
    }
}
```