Day 002 — 定数とiota

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

Goには他言語にあるようなenumというキーワードが存在しません。その代わりにconstブロックとiotaという特殊な仕組みを組み合わせて、列挙型（enum）に相当する概念を表現します。これはGoの「言語仕様は小さく保ち、既存の仕組み（型システム）を組み合わせて表現力を出す」という設計思想の典型例です。

const の基本

📋 コピーconst Pi = 3.14159
const MaxRetries = 3

varと違い、constで宣言した値はコンパイル時に確定し、実行中に変更できません。定数はゼロ値を持たず、必ず値を与える必要があります。

const ブロックと iota

複数の関連する定数をまとめて宣言する際は、constブロックを使います。

📋 コピーconst (
    Sunday = iota // 0
    Monday        // 1
    Tuesday       // 2
)

iotaはconstブロック内でのみ有効な「行カウンタ」です。ブロックの先頭で0から始まり、新しい行（定数宣言）が現れるたびに1ずつ増加します。2行目以降で式を省略すると、直前の行の式がそのまま繰り返されるため、iotaを使った式は自動的に増分されていきます。

なぜGoは enum キーワードを用意しなかったのか

enumを専用構文にすると、「取りうる値の集合を型として保証する」ための新しいコンパイラルールが必要になります。Goは代わりに「名前付きの型（named type）」+「const+iota」という既存の仕組みの組み合わせで同じ効果を実現しています。専用構文を増やさない代わりに、以下のような制約は言語レベルでは保証されません。

📋 コピーtype Weekday int

const (
    Sunday Weekday = iota
    Monday
    Tuesday
)

var w Weekday = 100 // コンパイルは通ってしまう（Weekdayとして未定義の値）

これは「シンプルさとのトレードオフ」であり、実務ではString()メソッドの実装やレビューでカバーする文化になっています。

iota を使ったビットフラグパターン

iotaはビットシフトと組み合わせることで、フラグの集合（複数のON/OFFを1つの整数で表現するパターン）にもよく使われます。

📋 コピーconst (
    ReadPermission  = 1 << iota // 1 << 0 = 1
    WritePermission             // 1 << 1 = 2
    ExecPermission              // 1 << 2 = 4
)

Stringer インターフェースによる可読な出力

const+iotaで作った値は素の整数なので、fmt.Printlnでそのまま出力すると0や1としか表示されません。String() stringメソッドを実装した型はfmt.Stringerインターフェースを満たし、fmt.Printlnや%vで自動的に人間が読める文字列に変換されます。

📋 コピーfunc (w Weekday) String() string {
    return [...]string{"Sunday", "Monday", "Tuesday"}[w]
}

📝 問題

タスク1（概念理解）:
以下の問いに簡潔に答えてください。

1. iotaはどのようなルールで値が増えていきますか。constブロックの何行目で何の値になるか説明してください。
2. Goにenumという専用キーワードがないのはなぜですか。代わりに何を組み合わせて列挙型を表現しますか。
3. 1 << iotaという書き方は何のためのパターンですか。

タスク2（実装）:
以下の要件を満たすmain.goを実装してください。

1. Seasonという名前付き型（type Season int）を定義し、constブロックとiotaを使ってSpring, Summer, Autumn, Winter（0〜3）を定義する
2. Season型にString() stringメソッドを実装し、fmt.Stringerインターフェースを満たすようにする（fmt.Println(season)で"Spring"のように表示されること）
3. type Permission intという名前付き型を定義し、1 << iotaパターンでRead, Write, Exec（1, 2, 4）の3つの権限フラグを定義する
4. ビットOR演算（|）で複数の権限を組み合わせた値を作り、ビットAND演算（&）で特定の権限を持っているかどうかを判定する関数HasPermission(p Permission, target Permission) boolを実装する
5. main関数内で、Seasonの全パターンをforループで出力し、権限の組み合わせ（例: Read+Write）を作ってHasPermissionで判定した結果を出力する

🔍 ヒント（段階的開示）

📋 コピーpackage main

import "fmt"

type Season int

const (
	Spring Season = iota
	Summer
	Autumn
	Winter
)

func (s Season) String() string {
	names := [...]string{"Spring", "Summer", "Autumn", "Winter"}
	return names[s]
}

type Permission int

const (
	Read Permission = 1 << iota
	Write
	Exec
)

func HasPermission(p Permission, target Permission) bool {
	// pにtargetのビットが全て含まれているかを判定
	return false // ここを実装
}

func main() {
	for s := Spring; s <= Winter; s++ {
		fmt.Println(s)
	}

	perms := Read | Write
	fmt.Println(HasPermission(perms, Read))
	fmt.Println(HasPermission(perms, Exec))
}

✅ 模範解答

📋 コピーpackage main

import "fmt"

// --- Season: iotaによる列挙 ---
type Season int

const (
	Spring Season = iota // 0
	Summer                // 1
	Autumn                // 2
	Winter                // 3
)

func (s Season) String() string {
	names := [...]string{"Spring", "Summer", "Autumn", "Winter"}
	if int(s) < 0 || int(s) >= len(names) {
		return "Unknown"
	}
	return names[s]
}

// --- Permission: 1 << iota によるビットフラグ ---
type Permission int

const (
	Read Permission = 1 << iota // 1 << 0 = 1
	Write                        // 1 << 1 = 2
	Exec                          // 1 << 2 = 4
)

func HasPermission(p Permission, target Permission) bool {
	return p&target == target
}

func main() {
	fmt.Println("--- Season（iotaによる列挙） ---")
	for s := Spring; s <= Winter; s++ {
		fmt.Printf("%d: %s\n", s, s)
	}

	fmt.Println("--- Permission（1 << iota によるビットフラグ） ---")
	perms := Read | Write
	fmt.Printf("perms = %d (Read+Write)\n", perms)
	fmt.Println("HasPermission(perms, Read):", HasPermission(perms, Read))
	fmt.Println("HasPermission(perms, Write):", HasPermission(perms, Write))
	fmt.Println("HasPermission(perms, Exec):", HasPermission(perms, Exec))

	all := Read | Write | Exec
	fmt.Printf("all = %d (Read+Write+Exec)\n", all)
	fmt.Println("HasPermission(all, Exec):", HasPermission(all, Exec))
}

--- Season（iotaによる列挙） ---
0: Spring
1: Summer
2: Autumn
3: Winter
--- Permission（1 << iota によるビットフラグ） ---
perms = 3 (Read+Write)
HasPermission(perms, Read): true
HasPermission(perms, Write): true
HasPermission(perms, Exec): false
all = 7 (Read+Write+Exec)
HasPermission(all, Exec): true

🪜 Step-by-Step 解説

📋 コピーtype Season int

📋 コピーconst (
	Spring Season = iota // 0
	Summer                // 1
	Autumn                // 2
	Winter                // 3
)

📋 コピーfunc (s Season) String() string {
	names := [...]string{"Spring", "Summer", "Autumn", "Winter"}
	return names[s]
}

📋 コピーconst (
	Read Permission = 1 << iota // 1 << 0 = 1
	Write                        // 1 << 1 = 2
	Exec                          // 1 << 2 = 4
)

📋 コピーfunc HasPermission(p Permission, target Permission) bool {
	return p&target == target
}

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

🌐 他言語との比較

Java/Python/TypeScriptのenumは「専用の型システムサポート」を持つ一方、Goのconst+iotaは「既存の仕組みの組み合わせ」です。安全性は一段階弱くなりますが、言語仕様がシンプルなままで済むという設計判断です。他言語経験者ほど「なぜGoにはenumがないのか」に違和感を覚えやすいポイントなので、この設計思想の違いを意識すると理解が深まります。

🏆 実務での使いどころ

• HTTPステータスコードの分類やAPIのステータス（Pending, Active, Completedなど）を表す型はconst+iota+Stringerで実装されることが非常に多い（構造体のフィールドとして持たせ、JSON出力時は文字列に変換するなど）
• ログレベル（Debug, Info, Warn, Error）は典型的なiotaベースの列挙パターンで、標準ライブラリのlog/slogもこの考え方に近い設計になっている
• Unix系のファイルパーミッション（読み取り・書き込み・実行）を扱うコードや、フィーチャーフラグ・権限管理システムでは1 << iotaによるビットフラグパターンが実際に使われる
• osパッケージのos.O_RDONLY, os.O_WRONLY, os.O_CREATEなどのファイルオープンフラグも、まさにこのiota+ビットシフトパターンで定義されている（標準ライブラリ自身がこのイディオムの実例）

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: SeasonにIsValid() boolメソッドを追加し、範囲外の値を検出できるようにしてみましょう。またiotaの応用として、_（ブランク識別子）で特定の値をスキップするパターンも調べてみましょう
• 次回予告: Day 003 — 制御構文（if/for/switch）（Goにはwhileがない理由・forの多用途性）

🎯 自己評価

自分の回答

気づき・メモ