Day 056 — macro_rules! の展開結果を予想する：フラグメント・衛生性・評価回数・edition 2024

📚 背景知識（読んでから問題へ）

Day 053〜055 の FFI では「C の関数ポインタとの境界」を扱いました。今日から1か月（〜2026-10-25）はマクロです。最初の1問は、書く前に「macro_rules! が何をしていて、何をしていないか」を正確に掴むための予想問題にします。

macro_rules! は構文木（トークン木）を受け取り、構文木を返す関数です。C のプリプロセッサのような文字列置換ではありません。この違いから、次の3つの性質が出てきます。

1つの規則は (マッチャ) => { トランスクライバ } の形で、上から順に試して最初に一致した規則だけが使われます。

📝 問題

cargo new macro_day056（edition 2024）の src/main.rs に下のマクロ定義と呼び出しがあります。コンパイルも実行もせずに、Q1〜Q8 の結果を予想し、それぞれ理由を1〜2文で書いてください。答えは各問の「答えを見る」で開けます（予想を書いてから開いてください）。最後に記述問題 Q9・Q10 に答えてください。

📋 コピーmacro_rules! square_plus_ten {
    ($e:expr) => {{
        let x = 10;
        $e * $e + x
    }};
}

let x = 2;
println!("Q1 = {}", square_plus_ten!(x));

📋 コピーmacro_rules! double_expr { ($e:expr) => { $e * 2 }; }
macro_rules! double_tt   { ($($t:tt)*) => { $($t)* * 2 }; }

println!("Q2a = {}", double_expr!(1 + 2));
println!("Q2b = {}", double_tt!(1 + 2));

📋 コピーmacro_rules! what {
    (0)        => { "literal 0" };
    ($e:expr)  => { "some expr" };
}
macro_rules! forward_expr { ($e:expr) => { what!($e) }; }
macro_rules! forward_tt   { ($t:tt)   => { what!($t) }; }

println!("Q3a = {}", what!(0));
println!("Q3b = {}", forward_expr!(0));
println!("Q3c = {}", forward_tt!(0));

📋 コピーmacro_rules! max_naive {
    ($a:expr, $b:expr) => { if $a > $b { $a } else { $b } };
}

let calls = Cell::new(0);
let next = || { calls.set(calls.get() + 1); calls.get() * 10 };   // 呼ぶたびに 10, 20, 30, ...
let m = max_naive!(next(), 5);
println!("Q4 = {m}, calls = {}", calls.get());

📋 コピーmacro_rules! which_rule {
    ($e:expr) => { "expr" };
    (_)       => { "underscore" };
}
println!("Q5 = {}", which_rule!(_));

📋 コピーmacro_rules! make_helper {
    () => { fn helper() -> &'static str { "from macro" } };
}
make_helper!();

fn main() { println!("Q6 = {}", helper()); }

📋 コピーmacro_rules! when {
    ($cond:expr $body:block) => { if $cond $body };
}

📋 コピーmacro_rules! sum { ($($x:expr),*) => { 0 $(+ $x)* }; }

println!("{}", sum!(1, 2, 3));
println!("{}", sum!(1, 2, 3,));
println!("{}", sum!());

Q9（記述）: max_naive! を直す

Q4 の問題を、マクロのまま直してください。std の assert_eq! が同じ問題をどう避けているかを参考にしてよいです。直した版が String のような Copy でない型でも使えるかどうかにも触れてください。

Q10（記述）: マクロにすべきか、ジェネリック関数にすべきか

次の3つを、それぞれ macro_rules! とジェネリック関数のどちらで書くべきか、理由とともに答えてください。

• (a) 2つの値の大きい方を返す max
• (b) hashmap!{ "a" => 1, "b" => 2 } のように、個数が決まっていないキーと値の組から HashMap を作る
• (c) u8 u16 u32 u64 i8 i16 i32 i64 の8つの型に、同じ中身の impl Checksum for T { ... } を書く

💡 ヒント

📋 コピーmacro_rules! max_once {
    ($a:expr, $b:expr) => {
        match ($a, $b) {
            (a, b) => { /* a と b を使う。$a と $b はもう書かない */ }
        }
    };
}

✅ 模範解答

答え（一覧）

検証用コード（cargo test / cargo run でそのまま確認できる完全版）

cargo new macro_day056 の src/main.rs をこれで置き換えます。外部クレートは不要、Cargo.toml は edition = "2024" のままです。

📋 コピーuse std::cell::Cell;

// Q1: 衛生性（ローカル変数）
macro_rules! square_plus_ten {
    ($e:expr) => {{
        let x = 10;
        $e * $e + x
    }};
}

// Q2: expr は1つの式として埋め込まれる / tt はトークン列のまま
macro_rules! double_expr {
    ($e:expr) => {
        $e * 2
    };
}
macro_rules! double_tt {
    ($($t:tt)*) => {
        $($t)* * 2
    };
}

// Q3: 一度 expr として捕まえた断片は、転送先で字句（リテラル）とは一致しない
macro_rules! what {
    (0) => {
        "literal 0"
    };
    ($e:expr) => {
        "some expr"
    };
}
macro_rules! forward_expr {
    ($e:expr) => {
        what!($e)
    };
}
macro_rules! forward_tt {
    ($t:tt) => {
        what!($t)
    };
}

// Q4: 引数の評価回数
macro_rules! max_naive {
    ($a:expr, $b:expr) => {
        if $a > $b { $a } else { $b }
    };
}
macro_rules! max_once {
    ($a:expr, $b:expr) => {
        match ($a, $b) {
            (a, b) => {
                if a > b { a } else { b }
            }
        }
    };
}

// Q5: edition 2024 で expr が `_` と `const { }` に一致するようになった
macro_rules! which_rule {
    ($e:expr) => {
        "expr"
    };
    (_) => {
        "underscore"
    };
}

// Q6: 項目（fn）は衛生的でない
macro_rules! make_helper {
    () => {
        fn helper() -> &'static str {
            "from macro"
        }
    };
}
make_helper!();

// Q8: 繰り返しと末尾カンマ
macro_rules! sum {
    ($($x:expr),* $(,)?) => {
        0 $(+ $x)*
    };
}

fn main() {
    let x = 2;
    println!("Q1 = {}", square_plus_ten!(x));

    println!("Q2a = {}", double_expr!(1 + 2));
    println!("Q2b = {}", double_tt!(1 + 2));

    println!("Q3a = {}", what!(0));
    println!("Q3b = {}", forward_expr!(0));
    println!("Q3c = {}", forward_tt!(0));

    let calls = Cell::new(0);
    let next = || {
        calls.set(calls.get() + 1);
        calls.get() * 10
    };
    let m = max_naive!(next(), 5);
    println!("Q4a = {m}, calls = {}", calls.get());
    calls.set(0);
    let m = max_once!(next(), 5);
    println!("Q4b = {m}, calls = {}", calls.get());

    println!("Q5 = {}", which_rule!(_));

    println!("Q6 = {}", helper());

    println!("Q8a = {}", sum!(1, 2, 3,));
    println!("Q8b = {}", sum!());
}

#[cfg(test)]
mod tests {
    use std::cell::Cell;

    #[test]
    fn q1_local_variables_are_hygienic() {
        let x = 2;
        assert_eq!(square_plus_ten!(x), 14); // 2*2 + 10。マクロ内の x=10 は呼び出し側の x を隠さない
    }

    #[test]
    fn q2_expr_is_one_node_tt_is_raw_tokens() {
        assert_eq!(double_expr!(1 + 2), 6); // (1 + 2) * 2
        assert_eq!(double_tt!(1 + 2), 5); //   1 + 2 * 2
    }

    #[test]
    fn q3_forwarded_expr_is_opaque() {
        assert_eq!(what!(0), "literal 0");
        assert_eq!(forward_expr!(0), "some expr");
        assert_eq!(forward_tt!(0), "literal 0");
    }

    #[test]
    fn q4_naive_max_evaluates_twice() {
        let calls = Cell::new(0);
        let next = || {
            calls.set(calls.get() + 1);
            calls.get() * 10
        };
        assert_eq!(max_naive!(next(), 5), 20);
        assert_eq!(calls.get(), 2);
        calls.set(0);
        assert_eq!(max_once!(next(), 5), 10);
        assert_eq!(calls.get(), 1);
        // 値で束縛するので Copy でない型も渡せる
        assert_eq!(max_once!(String::from("b"), String::from("a")), "b");
    }

    #[test]
    fn q5_edition_2024_expr_matches_underscore() {
        // Cargo.toml の edition を 2021 にすると "underscore" になる
        assert_eq!(which_rule!(_), "expr");
    }

    #[test]
    fn q6_items_are_not_hygienic() {
        assert_eq!(super::helper(), "from macro");
    }

    #[test]
    fn q8_trailing_comma_and_empty() {
        assert_eq!(sum!(1, 2, 3,), 6);
        assert_eq!(sum!(1, 2, 3), 6);
        assert_eq!(sum!(), 0);
    }
}

実測（出題者の環境: rustc 1.96.0 / edition 2024 / Apple M1 / macOS 26.5.1、2026-09-26）

cargo run -q の出力（実測）:

📋 コピーQ1 = 14
Q2a = 6
Q2b = 5
Q3a = literal 0
Q3b = some expr
Q3c = literal 0
Q4a = 20, calls = 2
Q4b = 10, calls = 1
Q5 = expr
Q6 = from macro
Q8a = 6
Q8b = 0

cargo test -q → test result: ok. 7 passed; 0 failed（実測）。cargo clippy -q --all-targets の警告は 0 件（実測）。

edition を変えた比較（実測。rustc --edition 2021|2024 で単体ファイルをビルド）:

rustc 1.85（edition 2024 が安定化した版）でも 2024 の列と同じ結果でした（実測。rustc +1.85）。

Q9 の回答

📋 コピーmacro_rules! max_once {
    ($a:expr, $b:expr) => {
        match ($a, $b) {
            (a, b) => { if a > b { a } else { b } }
        }
    };
}

• $a $b をトランスクライバに1回だけ書き、match のパターンで名前を付けてからその名前を使う。next() の呼び出しは1回になり（実測 calls = 1）、比較した値そのもの（10）が返る
• a b はマクロ内で束縛したローカル変数なので衛生的。呼び出し側に a という変数があっても衝突しない（Q1 と同じ仕組み）
• なぜ let ではなく match か: match の検査対象に置いた一時値は match 式全体の終わりまで生きるので、$a が一時値への参照を作る式でも寿命のエラーになりにくい。std の assert_eq! がこの形（rust-lang/rust 1.96.0 の library/core/src/macros/mod.rs 43〜44 行目: match (&$left, &$right) { (left_val, right_val) => ...）
• assert_eq! は比較するだけで値を消費してはいけないので参照で受ける。max は値を返すのが目的なので値で受ける。assert_eq! の真似で match (&$a, &$b) にして *a を返すと、String で E0507（実測。エラー5）。値で受けた版は max_once!(String::from("b"), String::from("a")) が "b" を返す（テストで確認）

Q10 の回答

🪜 Step-by-Step 解説

📋 コピー{ let x#macro = 10; x#caller * x#caller + x#macro }   // x#caller = 2 → 14

📋 コピーmacro_rules! when {
    ($cond:expr, $body:block) => { if $cond $body };
}
// when!(true, { println!("hi"); });

🧭 設計思想・なぜこう書くのか

Rust のマクロが「構文木を扱う」ことで得たものと払ったもの

判断の記録: 今日の問題を「予想問題」にした理由

🚨 コンパイルエラーが出た場合

以下はすべて出題者の環境（rustc 1.96.0、edition 2024、aarch64 macOS）で rustc --edition 2024 を実行して実際に出た出力です。

エラー1: follow-set 制限（Q7）

読み方: 指しているのは呼び出しではなく定義の行です。note に置けるトークンがそのまま書いてあります。

エラー2: 末尾カンマ（Q8、$(,)? が無い版）

読み方: note の「$x:expr に一致させようとしていた」が、カンマの後ろで次の要素を待っていたことを示しています。

エラー3: 呼び出し側の変数をマクロの中から直接使おうとした（衛生性）

📋 コピーmacro_rules! y_plus_one { () => { y + 1 }; }
fn main() { let y = 41; println!("{}", y_plus_one!()); }

help がはっきり「衛生性のせいで見えない」と言っています。直し方は ($y:ident) => { $y + 1 } として呼び出し側に名前を渡してもらうことです。

エラー4: 定義より前で使った（テキスト順のスコープ）

macro_rules! は関数と違い、ファイルの上から順に見えるようになります。別モジュールから使うには #[macro_use] か #[macro_export] が必要です。

エラー5: 繰り返しの深さの不一致と、参照で束縛した max

マッチャで $(...)* の中にあった $v は、トランスクライバでも $(...)* の中で使わなければなりません。

Q9 で assert_eq! の形（match (&$a, &$b)）をそのまま真似た版です。マクロでも所有権の規則は展開後のコードにそのまま掛かります。

🌐 他言語との比較

Go は言語にマクロを入れず、go generate でソースファイルを生成してコミットする方針を取りました。生成物がレビューできる代わりに、生成し忘れや差分のノイズが出ます。Rust の macro_rules! は生成物をファイルに残さない代わりに、cargo expand のような道具を使わないと展開後の形が見えません。

🏭 実務での使いどころ

• std の定番: vec!（$(,)?）、assert_eq!（match で1回評価）、println!（書式はコンパイラ組み込みの format_args! が解析）、matches!
• 数値型への一括 impl（Q10 (c)）: std 自身も各整数型のメソッドや From 実装をマクロで量産している
• テストの表駆動: test_cases! { add_small: (1, 2) => 3 } から #[test] fn add_small() を生成する。項目が衛生的でない（Q6）ことを逆に利用する
• ログ・計測のラッパ: 呼び出し位置（file!() line!()）を埋め込みたいときは関数ではなくマクロ。tracing::info! など

⚠️ よくある誤解・ミス

📎 一次資料（参照日: 2026-09-26。記述は各資料の要旨で、原文の引用ではありません）

• The Rust Reference — Macros By Example（フラグメント指定子、繰り返し、衛生性、follow-set 制限）: https://doc.rust-lang.org/reference/macros-by-example.html
• The Rust Edition Guide — Rust 2024: Macro Fragment Specifiers: https://doc.rust-lang.org/edition-guide/rust-2024/macro-fragment-specifiers.html
• The Little Book of Rust Macros: https://veykril.github.io/tlborm/
• rust-lang/rust 1.96.0 library/core/src/macros/mod.rs（assert_eq!。出題者が raw ファイルを取得して該当行を確認）: https://github.com/rust-lang/rust/blob/1.96.0/library/core/src/macros/mod.rs
• rust-lang/rust 1.96.0 library/alloc/src/macros.rs（vec!。同上）: https://github.com/rust-lang/rust/blob/1.96.0/library/alloc/src/macros.rs
• The Rust Programming Language — Macros: https://doc.rust-lang.org/book/ch20-05-macros.html

🚧 今日扱わなかった範囲（次回以降）

Rust Reference のフラグメント指定子は 15 種あり、今日の問題で実際に使ったのは expr expr_2021 tt block ident の 5 種（3分の1）です。

➡️ 次のステップ

• 発展: Q3 の what! に ($l:literal) => { what!($l) } 経由で 0 を渡すとどうなるか、予想してから試す
• 次回予告: マクロ① の2問目（実装）— hashmap!{ k => v, ... } を $(,)? 対応・with_capacity 付きで実装し、要素数をコンパイル時に数える count! を書く

🎯 自己評価（解いた後に記入）

自分の回答（Q1〜Q8 の予想と理由、Q9・Q10）

気づき・メモ