Day 021 — embedding（構造体・インターフェースの埋め込み）

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

Day 020では「小さいインターフェース」を利用側で定義し、暗黙的実装によって結合を緩める設計を学びました。今日はコード再利用の話です。Goにはclassもextendsもありません。継承（inheritance）の代わりにGoが用意しているのがembedding（埋め込み）です。

構造体にフィールド名を書かずに型だけを書くと、その型が「埋め込まれた（embedded）フィールド」になります。

📋 コピーtype BaseLogger struct {
	Prefix string
}

type TimestampLogger struct {
	BaseLogger // 埋め込み。フィールド名を書かない
	Clock func() string
}

これによりTimestampLoggerのインスタンスは、BaseLoggerが持つフィールド・メソッドをあたかも自分のものであるかのように呼び出せます（フィールド昇格・メソッド昇格）。tl.Prefixはtl.BaseLogger.Prefixの糖衣構文であり、tl.Log(...)はtl.BaseLogger.Log(...)の糖衣構文です。

ここで最も重要な注意点があります。embeddingは継承ではありません。仮想メソッドディスパッチ（virtual method dispatch）を提供しません。 Java/Python/C++のクラス継承では、親クラスのメソッドAの中から自分自身のメソッドBを呼ぶと、子クラスがBをオーバーライドしていればそちらが呼ばれます（動的束縛）。Goのembeddingではそうなりません。BaseLoggerのメソッドの中で自分のメソッドを呼んでも、それは常にBaseLogger自身のメソッドを指し、外側の型（TimestampLogger）が同名メソッドをオーバーライドしていても切り替わりません。埋め込まれた型は「自分が誰に埋め込まれているか」を一切知らないからです。これはGoの設計上、意図的な制約です——「暗黙のポリモーフィズムより、明示的な合成」というGoの哲学が構造体embeddingにも表れています。

真の多態性（同じインターフェース型に対して異なる実装が呼ばれる）が必要な場合は、構造体embeddingではなくインターフェースを使います。インターフェースにも同じ「埋め込み」の書き方があり、複数の小さいインターフェースを1つにまとめるのに使われます（例: io.ReadWriteCloserはio.Reader + io.Writer + io.Closerの埋め込みです）。インターフェース埋め込みは単なるメソッドセットの合併であり、構造体embeddingのような「知らないうちに落とし穴にはまる」問題は起きません。

📝 問題

簡易ロギングフレームワークを実装してください。

Part A: 構造体embeddingと「仮想ディスパッチがない」ことの実演

1. BaseLogger構造体を定義すること。フィールドはPrefix string。
   • メソッドLog(msg string) string: "[Prefix] msg"の形式の文字列を返す
   • メソッドLogAndAnnounce(msg string) string: 内部でl.Log(msg)を呼び出し、結果の先頭に"ANNOUNCE: "を付けて返す
2. TimestampLogger構造体を定義し、BaseLoggerを（フィールド名なしで）埋め込むこと。さらに独自フィールドClock func() string（時刻を返す関数。テストでモックできるようにするため）を持つこと。
3. TimestampLoggerにLog(msg string) stringメソッドを定義し、BaseLogger.Logをオーバーライド（同名メソッドで上書き）すること。返り値は"[Prefix] HH:MM:SS msg"の形式（l.Clock()を呼んで時刻文字列を取得する）。
4. 次の2つの呼び出し結果を予測してから実際にコードを実行し、結果が一致することを確認すること。
   • tl.Log("直接呼び出し") → タイムスタンプが付く
   • tl.LogAndAnnounce("間接呼び出し") → タイムスタンプが付かない（BaseLogger.LogAndAnnounce内のl.Log(msg)はBaseLogger.Logを指すため）
   • この結果を「実行結果と考察」として1〜2文でなぜそうなるか説明すること

Part B: インターフェースを使った「本物の多態性」への書き換え

5. Loggerインターフェース（Log(msg string) stringの1メソッド）を定義すること
6. LogAndAnnounceと同じ動作をする独立関数func Announce(l Logger, msg string) stringを定義すること（構造体メソッドではなく、Loggerインターフェースを受け取るパッケージ関数にする）
7. Announce(tl, "Announce経由")を呼び出すと、今度は正しくTimestampLogger.Log（タイムスタンプ付き）が使われることを確認すること

Part C: インターフェース埋め込み

8. Readerインターフェース（Read() (string, bool)）とWriterインターフェース（Write(s string) error）をそれぞれ定義すること
9. 両方を埋め込んだReadWriterインターフェースを定義すること（io.ReadWriteCloserと同じパターン）
10. MemBuffer構造体を実装し、Read/Write両方のメソッドを実装することでReadWriterを暗黙的に満たすこと（内部は[]stringのスライスと読み取り位置posで構わない）
11. var _ ReadWriter = (*MemBuffer)(nil)のようなコンパイル時アサーションで、MemBufferがReadWriterを満たすことを保証すること

すべてgo runまたはgo testでそのまま動作するコードとして提示すること。

🔍 ヒント（段階的開示）

📋 コピーpackage main

import "fmt"

type BaseLogger struct {
	Prefix string
}

func (l BaseLogger) Log(msg string) string {
	// TODO: "[Prefix] msg" 形式
}

func (l BaseLogger) LogAndAnnounce(msg string) string {
	// TODO: l.Log(msg) を呼び、"ANNOUNCE: " を前置
}

type TimestampLogger struct {
	BaseLogger
	Clock func() string
}

func (l TimestampLogger) Log(msg string) string {
	// TODO: "[Prefix] HH:MM:SS msg" 形式（l.Clock() を使う）
}

// Part B
type Logger interface {
	Log(msg string) string
}

func Announce(l Logger, msg string) string {
	// TODO: BaseLogger.LogAndAnnounce と同じロジックを、インターフェース経由で実装
}

// Part C
type Reader interface {
	// TODO
}
type Writer interface {
	// TODO
}
type ReadWriter interface {
	Reader
	Writer
}

type MemBuffer struct {
	data []string
	pos  int
}

// TODO: MemBuffer に Read/Write を実装
var _ ReadWriter = (*MemBuffer)(nil)

func main() {
	tl := TimestampLogger{
		BaseLogger: BaseLogger{Prefix: "APP"},
		Clock:      func() string { return "12:00:00" },
	}
	fmt.Println(tl.Log("直接呼び出し"))
	fmt.Println(tl.LogAndAnnounce("間接呼び出し"))
	fmt.Println(Announce(tl, "Announce経由"))
}

✅ 模範解答

ファイル: main.go

📋 コピーpackage main

import "fmt"

// ── Part A: 構造体embeddingとメソッドのオーバーライド ──

// BaseLogger は埋め込まれる側の基本ロガー。
type BaseLogger struct {
	Prefix string
}

func (l BaseLogger) Log(msg string) string {
	return fmt.Sprintf("[%s] %s", l.Prefix, msg)
}

// LogAndAnnounce は l.Log(msg) を呼び出す。
// 重要: この l は常に BaseLogger 型として解決される（静的束縛）。
// TimestampLogger が Log をオーバーライドしていても、この呼び出しは
// BaseLogger.Log のままであり、TimestampLogger.Log には切り替わらない。
func (l BaseLogger) LogAndAnnounce(msg string) string {
	return "ANNOUNCE: " + l.Log(msg)
}

// TimestampLogger は BaseLogger を埋め込み、Log を同名メソッドで上書き（シャドーイング）する。
type TimestampLogger struct {
	BaseLogger
	Clock func() string // テストで固定時刻を注入できるようにする
}

// Log は BaseLogger.Log をシャドーイングする。
// tl.Log(...) と直接呼んだ場合はこちらが呼ばれるが、
// BaseLogger.LogAndAnnounce の内部からは呼ばれない。
func (l TimestampLogger) Log(msg string) string {
	return fmt.Sprintf("[%s] %s %s", l.Prefix, l.Clock(), msg)
}

// ── Part B: インターフェース経由の「本物の多態性」──

// Logger は Log(msg string) string を持つ型の最小契約。
type Logger interface {
	Log(msg string) string
}

// Announce は BaseLogger.LogAndAnnounce と同じロジックだが、
// インターフェース引数として受け取ることで動的ディスパッチになる。
// l.Log(msg) は「実際に渡された型」の Log メソッドを呼ぶ。
func Announce(l Logger, msg string) string {
	return "ANNOUNCE: " + l.Log(msg)
}

// ── Part C: インターフェースの埋め込み ──

type Reader interface {
	Read() (string, bool)
}

type Writer interface {
	Write(s string) error
}

// ReadWriter は Reader と Writer のメソッドセットを合併しただけの
// インターフェース。io.ReadWriteCloser と同じパターン。
type ReadWriter interface {
	Reader
	Writer
}

// MemBuffer はメモリ上の文字列キューとして Read/Write を実装する。
type MemBuffer struct {
	data []string
	pos  int
}

func (b *MemBuffer) Write(s string) error {
	b.data = append(b.data, s)
	return nil
}

func (b *MemBuffer) Read() (string, bool) {
	if b.pos >= len(b.data) {
		return "", false
	}
	v := b.data[b.pos]
	b.pos++
	return v, true
}

// コンパイル時アサーション: *MemBuffer が ReadWriter を満たすことを保証する。
// 満たしていなければ go build がここでエラーになる。
var _ ReadWriter = (*MemBuffer)(nil)

func main() {
	tl := TimestampLogger{
		BaseLogger: BaseLogger{Prefix: "APP"},
		Clock:      func() string { return "12:00:00" },
	}

	fmt.Println(tl.Log("直接呼び出し"))
	fmt.Println(tl.LogAndAnnounce("間接呼び出し"))
	fmt.Println(Announce(tl, "Announce経由"))

	buf := &MemBuffer{}
	buf.Write("hello")
	buf.Write("world")
	for {
		v, ok := buf.Read()
		if !ok {
			break
		}
		fmt.Println("read:", v)
	}
}

ファイル: main_test.go

📋 コピーpackage main

import "testing"

func TestLogOverrideVsLogAndAnnounce(t *testing.T) {
	tl := TimestampLogger{
		BaseLogger: BaseLogger{Prefix: "APP"},
		Clock:      func() string { return "12:00:00" },
	}

	// 直接 Log を呼べば TimestampLogger.Log（タイムスタンプ付き）が使われる
	got := tl.Log("msg1")
	want := "[APP] 12:00:00 msg1"
	if got != want {
		t.Errorf("tl.Log() = %q, want %q", got, want)
	}

	// BaseLogger.LogAndAnnounce 経由だと BaseLogger.Log が使われ、
	// タイムスタンプは付かない（仮想ディスパッチが無いことの実演）
	got2 := tl.LogAndAnnounce("msg2")
	want2 := "ANNOUNCE: [APP] msg2"
	if got2 != want2 {
		t.Errorf("tl.LogAndAnnounce() = %q, want %q", got2, want2)
	}

	// Announce() はインターフェース経由なので TimestampLogger.Log が使われる
	got3 := Announce(tl, "msg3")
	want3 := "ANNOUNCE: [APP] 12:00:00 msg3"
	if got3 != want3 {
		t.Errorf("Announce(tl, ...) = %q, want %q", got3, want3)
	}
}

func TestMemBufferSatisfiesReadWriter(t *testing.T) {
	var rw ReadWriter = &MemBuffer{}
	if err := rw.Write("a"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if err := rw.Write("b"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	v1, ok1 := rw.Read()
	if !ok1 || v1 != "a" {
		t.Errorf("first Read() = (%q, %v), want (\"a\", true)", v1, ok1)
	}
	v2, ok2 := rw.Read()
	if !ok2 || v2 != "b" {
		t.Errorf("second Read() = (%q, %v), want (\"b\", true)", v2, ok2)
	}
	_, ok3 := rw.Read()
	if ok3 {
		t.Errorf("third Read() should return ok=false")
	}
}

$ go run .
[APP] 12:00:00 直接呼び出し
ANNOUNCE: [APP] 間接呼び出し
ANNOUNCE: [APP] 12:00:00 Announce経由
read: hello
read: world

$ go test ./...
ok  	example.com/day021	0.002s

※ main.go・main_test.goを1つのモジュール（go.modでmodule example.com/day021と宣言）として同一パッケージmainに配置しています。

🧭 実行結果と考察

🪜 Step-by-Step 解説

📋 コピーtype BaseLogger struct {
	Prefix string
}
func (l BaseLogger) Log(msg string) string {
	return fmt.Sprintf("[%s] %s", l.Prefix, msg)
}

📋 コピーtype TimestampLogger struct {
	BaseLogger
	Clock func() string
}

📋 コピーfunc (l TimestampLogger) Log(msg string) string {
	return fmt.Sprintf("[%s] %s %s", l.Prefix, l.Clock(), msg)
}

📋 コピーtype Logger interface { Log(msg string) string }
func Announce(l Logger, msg string) string {
	return "ANNOUNCE: " + l.Log(msg)
}

📋 コピーtype ReadWriter interface {
	Reader
	Writer
}

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

🌐 他言語との比較

Goのembeddingで最も注意すべきは、他言語の継承に慣れたエンジニアほど「オーバーライドすれば常にそちらが呼ばれる」という誤った直感を持ち込みやすい点である。Goでは「埋め込まれた型のメソッドの中で自分自身のメソッドを呼んでいる場合、それは静的に決まる」という事実を体で覚えておく必要がある。

🏆 実務での使いどころ

• 共通フィールド・共通メソッドの集約: CreatedAt/UpdatedAtのような監査用フィールドと、それに関するヘルパーメソッドをAuditFields構造体にまとめ、複数のドメインモデル（User, Orderなど）に埋め込むことで、各モデルの定義をシンプルに保てる
• 標準ライブラリのラッパー: sync.Mutexを構造体に埋め込んでLock()/Unlock()をそのまま昇格させる、あるいはhttp.ResponseWriterを埋め込んでレスポンスのステータスコードを記録するミドルウェア用ラッパーを作る、といったパターンが頻出する
• インターフェース埋め込みによる段階的な契約の合成: io.Reader/io.Writer/io.Closerのように、小さい契約を用途に応じてio.ReadCloser・io.WriteCloser・io.ReadWriteCloserと柔軟に組み合わせられるのは、標準ライブラリがインターフェース埋め込みを徹底しているから
• 「オーバーライドの罠」を避けるための設計判断: あるフィールドの挙動を外側の型で完全に差し替えたい場合、構造体embeddingではなく、最初からインターフェース経由の依存注入（Day 017や本日のPart Bのパターン）で設計しておくと、後から「オーバーライドしたのに反映されない」という事故を防げる

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: TimestampLoggerをさらに埋め込んだRequestScopedLogger（リクエストIDを付与する3階層目）を作り、tl.Log(...)・tl.LogAndAnnounce(...)それぞれの呼び出しでどのメソッドが解決されるかを、階層を1つ増やした状態で改めて予測・検証してみましょう
• 次回予告: Day 022 — ジェネリクス基礎（型パラメータ）（実装）。embeddingによるコード再利用の限界（型ごとに埋め込み先を書き分ける必要がある）を、型パラメータによる再利用でどう補完できるかを学びます

🎯 自己評価

自分の回答

気づき・メモ