// 定义宏
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
}

// 使用
fn main() {
    say_hello!();
}

macro_rules! greet {
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
    ($name:expr, $greeting:expr) => {
        println!("{}, {}!", $greeting, $name);
    };
}

fn main() {
    greet!("Rust");
    greet!("Rust", "Hi");
}

macro_rules! vec_of_strings {
    ($($s:expr),* $(,)?) => {
        vec![$($s.to_string()),*]
    };
}

fn main() {
    let v = vec_of_strings!["hello", "world", "rust"];
    println!("{:?}", v);
}

// HashMap 字面量宏
macro_rules! hashmap {
    ($($key:expr => $value:expr),* $(,)?) => {{
        let mut map = std::collections::HashMap::new();
        $(map.insert($key, $value);)*
        map
    }};
}

fn main() {
    let scores = hashmap! {
        "Alice" => 95,
        "Bob" => 87,
    };
    println!("{:?}", scores);
}

macro_rules! debug_print {
    ($var:ident) => {
        println!("{} = {:?}", stringify!($var), $var);
    };
    ($expr:expr) => {
        println!("{} = {:?}", stringify!($expr), $expr);
    };
}

fn main() {
    let x = 42;
    debug_print!(x);
    debug_print!(2 + 3);
}

macro_rules! time_it {
    ($label:expr, $block:block) => {{
        let start = std::time::Instant::now();
        let result = $block;
        let elapsed = start.elapsed();
        println!("{}: {:?}", $label, elapsed);
        result
    }};
}

fn main() {
    let sum = time_it!("求和", {
        (1..=1_000_000).sum::<i64>()
    });
    println!("结果: {}", sum);
}

macro_rules! impl_display {
    ($type:ty, $format:expr) => {
        impl std::fmt::Display for $type {
            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(f, $format, self)
            }
        }
    };
}

struct Point {
    x: f64,
    y: f64,
}

impl_display!(Point, "({}, {})");
// 这需要更复杂的宏来解构 self

fn main() {
    let p = Point { x: 1.0, y: 2.0 };
    println!("{}", p);
}