```rust
// Define a simple macro named `say_hello`
// that takes a name as an argument.
macro_rules! say_hello {
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
}

// Define a macro named `create_map`
// that takes key-value pairs and creates a HashMap.
macro_rules! create_map {
    ($($key:expr => $value:expr),*) => {{
        use std::collections::HashMap;
        let mut map = HashMap::new();
        $(
            map.insert($key, $value);
        )*
        map
    }};
}

fn main() {
    // Use the `say_hello` macro.
    say_hello!("Alice");
    say_hello!("Bob");

    // Use the `create_map` macro.
    let map = create_map! {
        "one" => 1,
        "two" => 2,
        "three" => 3
    };

    println!("The created map is: {:?}", map);
}
```

Example of macro_rules! - Rust Programming

```rust
#![feature(proc_macro_hygiene)]

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[macro_use]
extern crate quote;
#[macro_use]
extern crate syn;

// Define the custom derive macro for the `HelloMacro` trait.
macro_rules! hello_macro_derive {
    ($item:item) => {
        proc_macro::item(function! {
            // Parse the input tokens into a syntax tree.
            let ast = parse_macro_input!($item as DeriveInput);

            // Build the name of the type we want
            // to implement the trait for.
            let name = &ast.ident;

            // Generate the implementation of the `HelloMacro` trait.
            let gen = quote! {
                impl HelloMacro for #name {
                    fn hello_macro(&self) {
                        println!("Hello, Macro! My name is {}!", stringify!(#name));
                    }
                }
            };

            // Return the generated implementation
            // as a `TokenStream`.
            gen.into()
        })
    };
}

// Define the `HelloMacro` trait.
trait HelloMacro {
    fn hello_macro(&self);
}

// Define the `Person` struct and apply the custom derive macro.
hello_macro_derive! {
    struct Person {
        name: String,
    }
}

fn main() {
    // Create an instance of the `Person` struct.
    let person = Person {
        name: String::from("Alice"),
    };

    // Call the `hello_macro` method, which
    // is implemented via the custom derive macro.
    person.hello_macro();
}
```

Example of Derive Macro - Rust Programming

Macros in Rust are a way to define reusable chunks of code that are expanded at compile time. They are similar to macros in C/C++ and Lisp-like languages. Macros allow you to write code that generates other code, which can help reduce boilerplate and repetitive code. They can be used to create custom control structures or other constructs.

University of Michigan - Ann Arbor

Traits in Rust are a way to define shared behavior among different types. They are similar to interfaces in languages like Java or TypeScript. Traits define a set of methods that can be implemented by any type that wants to adhere to that behavior. Traits provide a way to define common functionality.

Traits - Rust Programming

rust-lang.org

```rust
// Define a trait named `Speak`
// with a single method `speak`.
trait Speak {
    fn speak(&self);
}

// Define a struct named `Human`.
struct Human {
    name: String,
}

// Implement the `Speak` trait for the `Human` struct.
impl Speak for Human {
    fn speak(&self) {
        println!("Hello, my name is {}.", self.name);
    }
}

// Define a struct named `Dog`.
struct Dog {
    name: String,
}

// Implement the `Speak` trait for the `Dog` struct.
impl Speak for Dog {
    fn speak(&self) {
        println!("Woof! My name is {}.", self.name);
    }
}

fn main() {
    // Create instances of `Human` and `Dog`.
    let person = Human {
        name: String::from("Alice"),
    };
    let dog = Dog {
        name: String::from("Buddy"),
    };

    // Call the `speak` method, which is
    // implemented via the `Speak` trait.
    person.speak();
    dog.speak();

    // Alternatively, use a function that takes
    // a reference to a `Speak` trait object.
    introduce_speaker(&person);
    introduce_speaker(&dog);
}

fn introduce_speaker(speaker: &dyn Speak) {
    speaker.speak();
}
```

Learn Before

Related

Learn After