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:

1. 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);

2. vec! Macro:

   • Used to create a Vec<T> easily.

   let numbers = vec![1, 2, 3, 4, 5];

3. 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]

4. vec! with Pattern Matching:

   • Create a vector with pattern matching.

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

5. 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");

6. cfg! Macro:

   • Conditional compilation based on configuration flags.

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

7. dbg! Macro:

   • A simple debugging macro for printing values.

   let x = 42;
   dbg!(x);

8. env! Macro:

   • Retrieve environment variables at compile time.

   let api_key = env!("API_KEY");

9. 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");

10. panic! Macro:

    • Abort the program with a panic message.

    panic!("Something went terribly wrong!");

11. cfg_attr! Macro:

    • Allows applying attributes conditionally based on configuration flags.

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

12. 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);

13. 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)
    }

14. concat! Macro:

    • Concatenates string literals at compile time.

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

15. file! and line! Macros:

    • Returns the current file path and line number at compile time.

    println!("File: {}, Line: {}", file!(), line!());

16. stringify! Macro:

    • Converts Rust source code into a string.

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

17. include! Macro:

    • Dynamically includes the content of a file during compilation.

    let included_code: &str = include!("some_file.rs");

18. format_args! Macro:

    • Constructs a std::fmt::Arguments structure for deferred formatting.

    let formatted_args = format_args!("{} + {} = {}", 2, 3, 2 + 3);

19. global_asm! Macro:

    • Inline assembly code at the global scope.

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

20. env! Macro with Default Value:

    • Retrieve an environment variable with a default value.

    let api_key = env!("API_KEY", default = "default_key");

21. 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!();
    }

22. 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!();
    }

23. 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!(),
        }
    }