Rustマクロで型推論を活用する方法とその利点を徹底解説

  macro_rules! say_hello {
      () => {
          println!("Hello, Rust!");
      };
  }
  say_hello!(); // Hello, Rust!

  #[derive(Debug)]
  struct MyStruct {
      value: i32,
  }

let x = 10;    // コンパイラは x の型を i32 と推論する
let y = 3.14; // コンパイラは y の型を f64 と推論する

fn add(a: i32, b: i32) -> i32 {
    a + b  // コンパイラが戻り値の型を i32 と推論
}

   let s = "Hello"; // &str 型として推論

   let sum = 5 + 10; // i32 型として推論

   fn square(num: f64) -> f64 {
       num * num
   }
   let result = square(4.5); // result は f64 型として推論

let num;  // 型が不明なためエラー
num = 5;

let num: i32;
num = 5;

macro_rules! double {
    ($x:expr) => {
        $x * 2
    };
}

fn main() {
    let int_result = double!(5);       // 型推論で i32 と判断
    let float_result = double!(3.5);   // 型推論で f64 と判断

    println!("{}", int_result);    // 10
    println!("{}", float_result);  // 7.0
}

macro_rules! create_vector {
    ($($elem:expr),*) => {
        vec![$($elem),*]
    };
}

fn main() {
    let integers = create_vector![1, 2, 3];           // Vec<i32> と推論
    let floats = create_vector![1.2, 3.4, 5.6];       // Vec<f64> と推論
    let strings = create_vector!["rust", "macro"];    // Vec<&str> と推論

    println!("{:?}", integers); // [1, 2, 3]
    println!("{:?}", floats);   // [1.2, 3.4, 5.6]
    println!("{:?}", strings);  // ["rust", "macro"]
}

use serde::Serialize;

#[derive(Serialize)]
struct User {
    name: String,
    age: u32,
}

fn main() {
    let user = User {
        name: "Alice".to_string(),
        age: 30,
    };

    println!("{:?}", serde_json::to_string(&user).unwrap());
}

macro_rules! double {
    ($x:expr) => {
        $x * 2
    };
}

fn main() {
    let int_result = double!(5);       // i32として推論される
    let float_result = double!(3.5);   // f64として推論される

    println!("i32の結果: {}", int_result);       // 出力: i32の結果: 10
    println!("f64の結果: {}", float_result);     // 出力: f64の結果: 7.0
}

macro_rules! sum_elements {
    ($($elem:expr),*) => {
        {
            let mut total = 0.0;
            $( total += $elem; )*
            total
        }
    };
}

fn main() {
    let result1 = sum_elements!(1, 2, 3, 4);         // 型推論で f64 として計算
    let result2 = sum_elements!(1.5, 2.5, 3.5);      // f64 のまま計算

    println!("合計 (整数): {}", result1);           // 出力: 合計 (整数): 10
    println!("合計 (浮動小数点): {}", result2);     // 出力: 合計 (浮動小数点): 7.5
}

macro_rules! repeat_value {
    ($val:expr, $times:expr) => {
        for _ in 0..$times {
            println!("{:?}", $val);
        }
    };
}

fn main() {
    repeat_value!("Rustマクロ", 3);     // &str 型として推論される
    repeat_value!(42, 2);               // i32 型として推論される
}

Rustマクロ  
Rustマクロ  
Rustマクロ  
42  
42  

macro_rules! calculate {
    ($x:expr, $op:tt, $y:expr) => {
        {
            $x $op $y
        }
    };
}

fn main() {
    let int_result = calculate!(10, +, 5);      // 型推論で i32 と判断
    let float_result = calculate!(7.5, *, 2.0); // 型推論で f64 と判断

    println!("i32の加算結果: {}", int_result);       // 出力: i32の加算結果: 15
    println!("f64の乗算結果: {}", float_result);     // 出力: f64の乗算結果: 15.0
}

macro_rules! create_struct {
    ($name:ident, { $($field:ident : $type:ty),* }) => {
        struct $name {
            $(pub $field: $type),*
        }
    };
}

create_struct!(User, { name: String, age: u32 });

fn main() {
    let user = User {
        name: "Alice".to_string(),
        age: 30,
    };

    println!("名前: {}, 年齢: {}", user.name, user.age);
}

macro_rules! handle_error {
    ($result:expr) => {
        match $result {
            Ok(val) => val,
            Err(e) => {
                eprintln!("エラー: {:?}", e);
                return;
            }
        }
    };
}

fn might_fail(success: bool) -> Result<i32, &'static str> {
    if success {
        Ok(42)
    } else {
        Err("何らかのエラーが発生しました")
    }
}

fn main() {
    let result = handle_error!(might_fail(true));
    println!("成功: {}", result);

    let result2 = handle_error!(might_fail(false)); // ここでエラーが処理され、関数が終了
    println!("この行は実行されません");
}

macro_rules! ambiguous_macro {
    ($x:expr) => {
        $x + $x
    };
}

fn main() {
    let result = ambiguous_macro!(2);
    // エラー: 型が曖昧 (i32, u32 など複数の可能性)
}

let result = ambiguous_macro!(2i32);  // i32 型を明示することでエラー解消

macro_rules! faulty_macro {
    ($x:expr) => {
        let result = $x * 2;
        println!("{}", result);
    };
}

fn main() {
    faulty_macro!("hello"); // コンパイルエラー
}

macro_rules! safe_macro {
    ($x:expr) => {
        if !$x.is_empty() {
            println!("Non-empty string: {}", $x);
        }
    };
}

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

fn main() {
    let result = add!(1, 2);  // 型が曖昧でエラーになることがある
}

let result = add!(1i32, 2i32);  // 型を i32 と明示

macro_rules! create_function {
    ($name:ident) => {
        fn $name() {
            println!("Function {} called", $name);
        }
    };
}

create_function!(my_func);

fn main() {
    my_func();
}

macro_rules! create_function {
    ($name:ident) => {
        fn $name() {
            println!("Function {} called", stringify!($name));
        }
    };
}

macro_rules! double {
    ($x:expr) => {
        $x * 2
    };
}

fn main() {
    let result = double!("hello");  // 文字列に乗算できないためエラー
}

let result = double!(5);  // 数値型を渡せばエラー解消

macro_rules! print_sum {
    ($a:expr, $b:expr) => {
        println!("{}", $a + $b);
    };
}

fn main() {
    print_sum!((2, 3));  // 誤ったカンマ区切りの引数でエラー
}

print_sum!(2, 3);

   cargo expand

fn main() {
    let int_result = triple!(4);      // 12として出力
    let float_result = triple!(2.5);  // 7.5として出力

    println!("i32の結果: {}", int_result);
    println!("f64の結果: {}", float_result);
}

fn main() {
    let vec1 = vec![1, 2, 3, 4];
    let vec2 = vec![1.5, 2.5, 3.5];

    println!("合計 (i32): {}", sum_vector!(vec1));  // 10と出力
    println!("合計 (f64): {}", sum_vector!(vec2));  // 7.5と出力
}

fn main() {
    let result1 = conditional_value!(true, 10, 20);
    let result2 = conditional_value!(false, "yes", "no");

    println!("条件結果 (i32): {}", result1);   // 10と出力
    println!("条件結果 (&str): {}", result2);  // "no"と出力
}

create_struct!(Person, name: String, age: u32);

fn main() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
    };

    println!("名前: {}, 年齢: {}", person.name, person.age);
}