Day 015 — Deref/DerefMutトレイト — スマートポインタの自動参照外し

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

Rustにおける「スマートポインタ」とは、単なる生ポインタ以上の機能（所有権管理・参照カウント・借用チェックなど）を持つ、ポインタのように振る舞う構造体のことです。この「ポインタのように振る舞う」を型システムのレベルで実現しているのがstd::ops::Derefトレイトです。

📋 コピーpub trait Deref {
    type Target: ?Sized;
    fn deref(&self) -> &Self::Target;
}

*my_valueという単項演算子*（デリファレンス）を自分の型に対して使えるようにするのがDerefトレイトです。コンパイラは*my_valueという式を見つけると、内部的には*(my_value.deref())に展開します。標準ライブラリのBox<T>はまさにこのDeref<Target = T>を実装しており、Box<i32>を*boxed_i32のようにデリファレンスして中のi32を取り出せるのはこの仕組みによるものです。

さらに重要なのがDeref coercion（デリファレンス型強制）です。これは関数・メソッド呼び出しの引数位置で、&Tが&Uを要求する場所に渡された場合、T: Deref<Target = U>であればコンパイラが自動的に.deref()を挟んでくれる機能です。

📋 コピーfn hello(name: &str) {
    println!("Hello, {name}!");
}

fn main() {
    let m = Box::new(String::from("Rust"));
    hello(&m); // &Box<String> → &String → &str と2段階のcoercionが自動適用される
}

&Box<String>を渡しているのに&strを受け取る関数がそのまま呼べるのは、Box<String>: Deref<Target = String>かつString: Deref<Target = str>という連鎖的なcoercionをコンパイラが自動適用しているためです。これにより、呼び出し側は毎回&*mやm.as_str()のような明示的な変換を書く必要がなくなります。

可変版がDerefMutです。

📋 コピーpub trait DerefMut: Deref {
    fn deref_mut(&mut self) -> &mut Self::Target;
}

注目すべきはDerefMut: Derefというスーパートレイト境界です。「書き込みできる（deref_mut）なら読み込みもできる（deref）はず」という自然な包含関係を、コンパイラがトレイト境界のレベルで強制しています。DerefMutだけを単独で実装することはできません。

📝 問題

以下の4つの要求に順番に答えてください。

要求1（概念理解）

次のコードがコンパイルが通り、かつ実行できる理由を、Derefトレイトの仕組み（*演算子の展開ルールとDeref coercion）に基づいて説明してください。

📋 コピーfn print_upper(s: &str) {
    println!("{}", s.to_uppercase());
}

fn main() {
    let boxed = Box::new(String::from("hello"));
    print_upper(&boxed); // なぜ &Box<String> を &str が要求される場所に渡せるのか？
    println!("first char via deref: {}", (*boxed).chars().next().unwrap());
}

要求2（実装: 独自スマートポインタとDeref coercion）

Box<T>と同じような「中身を1つだけ保持するだけのシンプルなラッパー型」MyBox<T>を自作し、Derefを実装してください。そのうえで、fn greet(name: &str)のような関数に&MyBox<String>を渡し、Deref coercionが2段階（MyBox<String> → String → str）で効くことをmain関数の中で実証してください。

要求3（実装: DerefMut）

読み書きのたびにログを出すLoggingBox<T>型を実装してください。

• Deref実装: .deref()が呼ばれたら"[read] value accessed"を標準出力に出す
• DerefMut実装: .deref_mut()が呼ばれたら"[write] value accessed (mutably)"を標準出力に出す
• LoggingBox<i32>を作り、*logging_box += 10;のように中身を書き換えるコードを書き、書き込み時にDerefMut側のログが出ることを#[cfg(test)]のテストで検証してください（出力の検証ではなく、書き換え後の値が正しいことをテストで検証すれば十分です）

要求4（概念理解・設計判断）

DerefMutがDerefのスーパートレイトになっている（DerefMut: Deref）のはなぜだと思いますか。もし逆に「Derefを実装せずにDerefMutだけを実装できる」設計だったとしたら、どのような不自然な状況が起こり得るか、具体例を挙げて説明してください。

🔍 ヒント（段階的開示）

📋 コピーuse std::ops::{Deref, DerefMut};

struct MyBox<T>(T);

impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.0
    }
}

struct LoggingBox<T>(T);

impl<T> Deref for LoggingBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        println!("[read] value accessed");
        &self.0
    }
}

impl<T> DerefMut for LoggingBox<T> {
    fn deref_mut(&mut self) -> &mut T {
        println!("[write] value accessed (mutably)");
        &mut self.0
    }
}

✅ 模範解答

📋 コピーuse std::ops::{Deref, DerefMut};

// 要求2: Box<T> の簡易版。中身を1つ保持するだけのタプル構造体
struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(value: T) -> MyBox<T> {
        MyBox(value)
    }
}

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

fn greet(name: &str) {
    println!("Hello, {name}!");
}

// 要求3: 読み書きでログを出す LoggingBox<T>
struct LoggingBox<T>(T);

impl<T> LoggingBox<T> {
    fn new(value: T) -> LoggingBox<T> {
        LoggingBox(value)
    }
}

impl<T> Deref for LoggingBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        println!("[read] value accessed");
        &self.0
    }
}

impl<T> DerefMut for LoggingBox<T> {
    fn deref_mut(&mut self) -> &mut T {
        println!("[write] value accessed (mutably)");
        &mut self.0
    }
}

fn main() {
    // 要求1の再確認: Box<T> の Deref coercion
    let boxed = Box::new(String::from("hello"));
    print_upper(&boxed);
    println!("first char via deref: {}", (*boxed).chars().next().unwrap());

    // 要求2: MyBox<String> → String → str と2段階の coercion が効く
    let m = MyBox::new(String::from("Rust"));
    greet(&m); // &MyBox<String> をそのまま &str が要求される場所に渡せる

    // 要求3: DerefMut による書き込み
    let mut counter = LoggingBox::new(0);
    println!("before: {}", *counter); // [read] ログが出る
    *counter += 10; // [write] ログが出る（deref_mut 経由）
    println!("after: {}", *counter); // [read] ログが出る
}

fn print_upper(s: &str) {
    println!("{}", s.to_uppercase());
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn mybox_deref_coercion_reaches_str_methods() {
        let m = MyBox::new(String::from("rust"));
        // &MyBox<String> → &String → &str の coercion が効くことの確認
        assert_eq!(m.len(), 4); // String::len (実際は str::len) が自動で呼べる
        assert_eq!(&*m, "rust");
    }

    #[test]
    fn loggingbox_deref_mut_actually_mutates_inner_value() {
        let mut lb = LoggingBox::new(5);
        assert_eq!(*lb, 5);
        *lb += 10;
        assert_eq!(*lb, 15);
    }

    #[test]
    fn loggingbox_deref_mut_supports_method_calls_on_inner_vec() {
        let mut lb = LoggingBox::new(vec![1, 2, 3]);
        lb.push(4); // DerefMut coercion により Vec::push が呼べる
        assert_eq!(*lb, vec![1, 2, 3, 4]);
    }
}

$ cargo run
HELLO
first char via deref: h
Hello, Rust!
[read] value accessed
before: 0
[write] value accessed (mutably)
[read] value accessed
after: 10

$ cargo test
running 3 tests
test tests::loggingbox_deref_mut_actually_mutates_inner_value ... ok
test tests::loggingbox_deref_mut_supports_method_calls_on_inner_vec ... ok
test tests::mybox_deref_coercion_reaches_str_methods ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

🪜 Step-by-Step 解説

📋 コピーimpl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.0
    }
}

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

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

Derefを実装し忘れた型に対して*を使おうとすると、次のようなエラーが出ます。

読み方:

• type 'MyBox<i32>' cannot be dereferenced: *演算子を使おうとしたが、MyBox<i32>はDerefを実装していないため、コンパイラは*mをderef呼び出しに展開する方法を知らない、という意味です
• 修正方法はimpl Deref for MyBox<T>を追加することです

また、DerefMutだけを実装しDerefを実装し忘れた場合は、次のようなエラーになります。

読み方: DerefMut: Derefというスーパートレイト境界がある以上、Derefを実装していない型にDerefMutだけを実装することはできません。まずDerefを実装してからDerefMutを実装する必要があります。

🌐 他言語との比較

Go言語の構造体埋め込みはDerefと目的が似ています（内側の型のフィールド・メソッドをあたかも自分のものであるかのように使える）が、コンパイラが自動で行う「昇格（promotion）」というメカニズムであり、Rustのように明示的なトレイト実装を要求しません。Rustが明示的なimpl Derefを要求するのは、「この型はポインタのように振る舞ってよい」という意図をコード上で宣言させるためであり、暗黙のうちに継承的な関係が生まれることを防ぐ設計判断です。

🏆 実務での使いどころ

• 標準ライブラリの至るところで採用されている: String: Deref<Target = str>・Vec<T>: Deref<Target = [T]>・Box<T>: Deref<Target = T>・Rc<T>: Deref<Target = T>など、所有権付きの型からその「借用版」の型へ自然にアクセスできるようにする、標準ライブラリ全体を貫く設計パターンです
• ロックガード型: std::sync::MutexGuard<T>はDeref/DerefMutを実装しており、*guardで中身にアクセスできます。ロックの取得・解放（Dropによるアンロック）という重要な副作用を隠しながら、利用者には「ただの値」のように見せる、実務での典型的な応用例です
• newtypeパターンでのエルゴノミクス確保: ドメイン型（例: UserId(String)のようなnewtype）に対してバリデーション付きのラッパーを被せつつ、Derefを実装することで既存の&strメソッド群をそのまま呼べるようにする、というテクニックが実務で使われます（ただし濫用は次の「よくある誤解」で触れる問題を招きます）

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: MyBox<T>にDropトレイトも実装し、「値がスコープを抜けるときにログを出す」ことで、Box<T>が単なるDerefだけでなく所有権の破棄タイミングまで管理していることを体感してみてください
• 次回予告: Day 016ではIteratorトレイトとイテレータアダプタを扱います。map/filter/foldなどの連鎖処理が、実際にはどのようなトレイトメソッドの組み合わせで動いているかを学びます

🎯 自己評価

自分の回答

気づき・メモ