Day 057 — マクロ① macro_rules! ② hashmap! と count! を実装する：ty・ident・vis・meta と「数え方」の選択

• 課題1: 「数を足す」のではなく「同じ個数の何かを並べて、並べたものの長さを聞く」と考えると、再帰が要らなくなります
• 課題2: 要件5は昨日の Step 3（型名は呼び出し側で解決される）、要件3は Q4（何回書いたか）、要件6は「0回の繰り返しで何が残るか」を思い出してください
• 課題4: vis は「何も書かれていない」にも一致します。$vis:vis struct と書けば pub の有無の両方を1つの規則で受けられます

• 課題1: macro_rules! の中に、外から呼ぶつもりのない内部規則を (@unit $_t:tt) => { () }; のように @ で始めて置くのが慣習です。各要素を () に変えて [(), (), ()] を作り、<[()]>::len(&[...]) を呼びます。<[T]>::len は const fn なので const の初期化に使えます
• 課題1: hashmap! から count! へキーを渡すとき、キーはもう expr の塊です。count! 側を $x:tt で受ければ、塊は1個のトークン木として一致します（昨日の Q3 の逆向き）
• 課題2: 絶対パス ::std::collections::HashMap と、同じクレートのマクロを呼ぶ $crate::count! を使います
• 課題2: ヒープ確保の回数は、std::alloc::System に委譲しつつ alloc と realloc で数える GlobalAlloc を書けば取れます。cargo test はテストを並列スレッドで走らせるので、カウンタの置き場所に注意

📋 コピーmacro_rules! count {
    (@unit $_t:tt) => { () };
    ($($x:tt),* $(,)?) => { <[()]>::len(&[ $( $crate::count!(@unit $x) ),* ]) };
}

#[macro_export]
macro_rules! hashmap {
    () => { /* 0要素の規則を先に */ };
    ($($k:expr => $v:expr),* $(,)?) => {{
        let mut map = ::std::collections::HashMap::with_capacity($crate::count!($($k),*));
        $( map.insert($k, $v); )*
        map
    }};
}

macro_rules! newtype {
    ($(#[$m:meta])* $vis:vis struct $name:ident($inner:ty);) => {
        $(#[$m])*
        $vis struct $name($inner);
        // impl $name { ... } と impl From<$inner> for $name { ... }
    };
}

📋 コピーuse std::alloc::{GlobalAlloc, Layout, System};
use std::collections::HashMap;
use std::cell::Cell;

// ---------- 計測用: ヒープ確保の回数を「スレッドごとに」数えるアロケータ ----------
// cargo test はテストを並列スレッドで走らせるので、グローバルな1個のカウンタだと
// 他のテストの確保まで数えてしまう（実測: 1 のはずが 9）。
struct CountingAlloc;
thread_local! {
    static ALLOCS: Cell<usize> = const { Cell::new(0) };
}
fn bump() {
    ALLOCS.with(|c| c.set(c.get() + 1));
}

unsafe impl GlobalAlloc for CountingAlloc {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        bump();
        unsafe { System.alloc(layout) }
    }
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        unsafe { System.dealloc(ptr, layout) }
    }
    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
        bump();
        unsafe { System.realloc(ptr, layout, new_size) }
    }
}

#[global_allocator]
static GLOBAL: CountingAlloc = CountingAlloc;

fn allocs_during<T>(f: impl FnOnce() -> T) -> (T, usize) {
    let before = ALLOCS.with(Cell::get);
    let out = f();
    (out, ALLOCS.with(Cell::get) - before)
}

// ---------- 課題1: count! — 要素数をコンパイル時の定数として数える ----------
#[macro_export]
macro_rules! count {
    // 内部規則: どんなトークン木も () に置き換える
    (@unit $_t:tt) => { () };
    ($($x:tt),* $(,)?) => {
        <[()]>::len(&[$($crate::count!(@unit $x)),*])
    };
}

// 比較用: 再帰で数える素朴版（要素数ぶん再帰する）
#[macro_export]
macro_rules! count_rec {
    () => { 0usize };
    ($head:tt $(, $rest:tt)* $(,)?) => { 1usize + $crate::count_rec!($($rest),*) };
}

// ---------- 課題2: hashmap! ----------
#[macro_export]
macro_rules! hashmap {
    // 0要素の規則を先に置く。無いと下の規則で `let mut map` が一度も変更されず unused_mut 警告
    () => { ::std::collections::HashMap::new() };
    ($($k:expr => $v:expr),* $(,)?) => {{
        let mut map = ::std::collections::HashMap::with_capacity($crate::count!($($k),*));
        $( map.insert($k, $v); )*
        map
    }};
}

// 比較用: with_capacity を付けない版
macro_rules! hashmap_nocap {
    ($($k:expr => $v:expr),* $(,)?) => {{
        let mut map = ::std::collections::HashMap::new();
        $( map.insert($k, $v); )*
        map
    }};
}

// ---------- 課題3: impl_checksum! — ty フラグメントで8型に独立した impl ----------
pub trait Checksum {
    /// リトルエンディアンのバイト列を足し合わせた 8bit チェックサム
    fn checksum(&self) -> u8;
}

macro_rules! impl_checksum {
    ($($t:ty),+ $(,)?) => {
        $(
            impl Checksum for $t {
                fn checksum(&self) -> u8 {
                    self.to_le_bytes().iter().fold(0u8, |acc, b| acc.wrapping_add(*b))
                }
            }
        )+
    };
}
impl_checksum!(u8, u16, u32, u64, i8, i16, i32, i64);

// ---------- 課題4: newtype! — meta / vis / ident / ty ----------
macro_rules! newtype {
    ($(#[$m:meta])* $vis:vis struct $name:ident($inner:ty);) => {
        $(#[$m])*
        $vis struct $name($inner);

        impl $name {
            $vis fn new(v: $inner) -> Self { Self(v) }
            $vis fn into_inner(self) -> $inner { self.0 }
        }

        impl ::std::convert::From<$inner> for $name {
            fn from(v: $inner) -> Self { Self(v) }
        }
    };
}

mod ids {
    newtype! {
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        pub struct UserId(u64);
    }
    newtype! {
        #[derive(Debug)]
        struct Secret(String); // vis 無し = このモジュール内だけ
    }
    pub fn secret_len() -> usize {
        Secret::new("hunter2".to_string()).into_inner().len()
    }
}
use ids::UserId;

const N_KEYS: usize = count!(a, b, c, d);
const N_REC: usize = count_rec!(a, b, c, d);

fn main() {
    println!("count!(a, b, c, d) = {N_KEYS}, count_rec! = {N_REC}");
    println!("count!() = {}", count!());

    let m = hashmap! { "apple" => 3, "banana" => 5, "cherry" => 7, };
    let mut keys: Vec<_> = m.keys().copied().collect();
    keys.sort();
    println!("hashmap! keys = {keys:?}, len = {}, capacity >= len: {}", m.len(), m.capacity() >= m.len());

    let dup = hashmap! { "k" => 1, "k" => 2 };
    println!("duplicate key: len = {}, k = {}", dup.len(), dup["k"]);

    let empty: HashMap<&str, i32> = hashmap! {};
    println!("empty: len = {}, capacity = {}", empty.len(), empty.capacity());

    // ヒープ確保回数の比較（100要素）
    let (_, with_cap) = allocs_during(|| hashmap! {
        0=>0,1=>1,2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,11=>11,12=>12,13=>13,14=>14,15=>15,16=>16,17=>17,18=>18,19=>19,
        20=>20,21=>21,22=>22,23=>23,24=>24,25=>25,26=>26,27=>27,28=>28,29=>29,30=>30,31=>31,32=>32,33=>33,34=>34,35=>35,36=>36,37=>37,38=>38,39=>39,
        40=>40,41=>41,42=>42,43=>43,44=>44,45=>45,46=>46,47=>47,48=>48,49=>49,50=>50,51=>51,52=>52,53=>53,54=>54,55=>55,56=>56,57=>57,58=>58,59=>59,
        60=>60,61=>61,62=>62,63=>63,64=>64,65=>65,66=>66,67=>67,68=>68,69=>69,70=>70,71=>71,72=>72,73=>73,74=>74,75=>75,76=>76,77=>77,78=>78,79=>79,
        80=>80,81=>81,82=>82,83=>83,84=>84,85=>85,86=>86,87=>87,88=>88,89=>89,90=>90,91=>91,92=>92,93=>93,94=>94,95=>95,96=>96,97=>97,98=>98,99=>99,
    });
    let (_, no_cap) = allocs_during(|| hashmap_nocap! {
        0=>0,1=>1,2=>2,3=>3,4=>4,5=>5,6=>6,7=>7,8=>8,9=>9,10=>10,11=>11,12=>12,13=>13,14=>14,15=>15,16=>16,17=>17,18=>18,19=>19,
        20=>20,21=>21,22=>22,23=>23,24=>24,25=>25,26=>26,27=>27,28=>28,29=>29,30=>30,31=>31,32=>32,33=>33,34=>34,35=>35,36=>36,37=>37,38=>38,39=>39,
        40=>40,41=>41,42=>42,43=>43,44=>44,45=>45,46=>46,47=>47,48=>48,49=>49,50=>50,51=>51,52=>52,53=>53,54=>54,55=>55,56=>56,57=>57,58=>58,59=>59,
        60=>60,61=>61,62=>62,63=>63,64=>64,65=>65,66=>66,67=>67,68=>68,69=>69,70=>70,71=>71,72=>72,73=>73,74=>74,75=>75,76=>76,77=>77,78=>78,79=>79,
        80=>80,81=>81,82=>82,83=>83,84=>84,85=>85,86=>86,87=>87,88=>88,89=>89,90=>90,91=>91,92=>92,93=>93,94=>94,95=>95,96=>96,97=>97,98=>98,99=>99,
    });
    let (_, from_arr) = allocs_during(|| {
        let arr: [(i32, i32); 100] = std::array::from_fn(|i| (i as i32, i as i32));
        HashMap::from(arr)
    });
    println!("allocs for 100 entries: hashmap! = {with_cap}, no with_capacity = {no_cap}, HashMap::from([..;100]) = {from_arr}");

    println!("checksum: 0x0102u16 = {}, -1i32 = {}, 300u64 = {}", 0x0102u16.checksum(), (-1i32).checksum(), 300u64.checksum());

    let id = UserId::new(42);
    let id2: UserId = 42.into();
    println!("newtype: {:?} == {:?} -> {}, inner = {}, secret_len = {}", id, id2, id == id2, id.into_inner(), ids::secret_len());
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn count_is_a_const() {
        const N: usize = count!(x, y, z);
        let arr = [0u8; N]; // 配列長に使える = コンパイル時定数
        assert_eq!(arr.len(), 3);
        assert_eq!(count!(), 0);
        assert_eq!(count!(a,), 1);
        assert_eq!(count!((1, 2), [3, 4], { 5 }), 3); // 括弧のまとまりは1個の tt
    }

    #[test]
    fn count_matches_recursive_version() {
        assert_eq!(count!(a, b, c, d, e), count_rec!(a, b, c, d, e));
    }

    #[test]
    fn hashmap_basic_and_trailing_comma() {
        let m = hashmap! { "a" => 1, "b" => 2, };
        assert_eq!(m.len(), 2);
        assert_eq!(m["a"], 1);
        let m2 = hashmap! { "a" => 1 };
        assert_eq!(m2["a"], 1);
    }

    #[test]
    fn hashmap_empty_needs_annotation() {
        let m: HashMap<String, u8> = hashmap! {};
        assert!(m.is_empty());
    }

    #[test]
    fn hashmap_duplicate_key_last_wins() {
        let m = hashmap! { "k" => 1, "k" => 2 };
        assert_eq!(m.len(), 1);
        assert_eq!(m["k"], 2);
    }

    #[test]
    fn hashmap_evaluates_each_expr_once_in_order() {
        let log = Cell::new(0u32);
        let tick = |tag: u32| { log.set(log.get() * 10 + tag); tag };
        let m = hashmap! { tick(1) => tick(2), tick(3) => tick(4) };
        assert_eq!(log.get(), 1234); // k1, v1, k2, v2 の順に1回ずつ
        assert_eq!(m.len(), 2);
    }

    #[test]
    fn hashmap_local_name_is_hygienic() {
        let map = "caller's map";
        let m = hashmap! { map => 1 }; // マクロ内の `map` と衝突しない
        assert_eq!(m["caller's map"], 1);
    }

    #[test]
    fn hashmap_preallocates() {
        let (_, n) = allocs_during(|| hashmap! { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8 });
        assert_eq!(n, 1);
    }

    #[test]
    fn checksum_all_eight_types() {
        assert_eq!(0xFFu8.checksum(), 0xFF);
        assert_eq!(0x0102u16.checksum(), 3);
        assert_eq!((-1i32).checksum(), 0xFC); // FF*4 = 0x3FC → 下位 8bit
        assert_eq!(300u64.checksum(), 45); // 0x012C → 0x2C + 0x01
        assert_eq!((-1i8).checksum(), 0xFF);
        assert_eq!(1i16.checksum(), 1);
        assert_eq!(1u32.checksum(), 1);
        assert_eq!(1i64.checksum(), 1);
    }

    #[test]
    fn newtype_generates_struct_and_from() {
        let a = UserId::new(7);
        let b: UserId = 7u64.into();
        assert_eq!(a, b);
        assert_eq!(a.into_inner(), 7);
        assert_eq!(ids::secret_len(), 7);
    }
}