@k2works/claude-code-booster 3.0.0 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/scala/07-case-classes-and-traits.md

@@ -0,0 +1,139 @@
+# 第 7 章: ケースクラスとトレイトによるポリモーフィズム
+
+## 7.1 はじめに
+
+第 1 部〜第 2 部で TDD の基本サイクルと開発環境を整えました。ここからは FizzBuzz に追加仕様を導入し、オブジェクト指向設計を進めます。
+
+今回の追加仕様は、FizzBuzz のタイプバリエーションです。
+
+- Type01: 通常の FizzBuzz（3 の倍数で Fizz、5 の倍数で Buzz、15 の倍数で FizzBuzz）
+- Type02: 数値のみ（常に数値文字列を返す）
+- Type03: FizzBuzz のみ（15 の倍数のみ FizzBuzz、それ以外は数値文字列）
+
+Scala では `case class` と `trait` を組み合わせることで、型安全なポリモーフィズムをシンプルに表現できます。
+
+## 7.2 TODO リスト
+
+既存 TODO に加えて、タイプバリエーションに関する TODO を整理します。
+
+- [x] ~~1 を渡したら "1" を返す~~
+- [x] ~~3 の倍数のときは "Fizz" を返す~~
+- [x] ~~5 の倍数のときは "Buzz" を返す~~
+- [x] ~~15 の倍数のときは "FizzBuzz" を返す~~
+- [x] ~~1 から 100 までのリストを返す~~
+- [ ] Type01 のルールを実装する
+- [ ] Type02 のルールを実装する
+- [ ] Type03 のルールを実装する
+- [ ] 未定義タイプで例外を送出する
+
+## 7.3 値オブジェクト（case class）
+
+単一値の表現には `case class FizzBuzzValue` を使います。
+
+```scala
+case class FizzBuzzValue(number: Int, value: String):
+  require(number > 0, s"数値は正の整数でなければなりません: $number")
+  override def toString: String = value
+```
+
+`case class` の主な特徴は次のとおりです。
+
+- 不変データを簡潔に定義できる
+- `equals` / `hashCode` / `toString` が自動生成される
+- パターンマッチに自然に対応できる
+
+また、`require` により「正の整数であること」という事前条件をコンストラクタ境界で保証しています。
+
+## 7.4 ファーストクラスコレクション
+
+複数値の表現には `FizzBuzzList` を使います。
+
+```scala
+case class FizzBuzzList(values: List[FizzBuzzValue]):
+  require(values.nonEmpty, "リストは空であってはなりません")
+  def toStringList: List[String] = values.map(_.value)
+  def count: Int = values.length
+```
+
+`List[FizzBuzzValue]` を直接扱わず、`FizzBuzzList` にラップすることで、コレクション操作をドメインの語彙で表現できます。
+
+実装ではコンパニオンオブジェクトに `create` を持たせ、生成ロジックを集約しています。
+
+```scala
+object FizzBuzzList:
+  def create(count: Int, fizzBuzzType: FizzBuzzType): FizzBuzzList =
+    val values = (1 to count).map { n =>
+      FizzBuzzValue(n, fizzBuzzType.generate(n))
+    }.toList
+    FizzBuzzList(values)
+```
+
+## 7.5 トレイトによるポリモーフィズム
+
+FizzBuzz のタイプごとの差し替えポイントは `FizzBuzzType` で抽象化します。
+
+```scala
+sealed trait FizzBuzzType:
+  def generate(number: Int): String
+```
+
+実装は 3 つの `case object` です。
+
+```scala
+object FizzBuzzType:
+  case object Type01 extends FizzBuzzType:
+    def generate(number: Int): String =
+      number match
+        case n if n % 15 == 0 => "FizzBuzz"
+        case n if n % 3 == 0  => "Fizz"
+        case n if n % 5 == 0  => "Buzz"
+        case n                => n.toString
+
+  case object Type02 extends FizzBuzzType:
+    def generate(number: Int): String = number.toString
+
+  case object Type03 extends FizzBuzzType:
+    def generate(number: Int): String =
+      number match
+        case n if n % 15 == 0 => "FizzBuzz"
+        case n                => n.toString
+```
+
+`sealed` を付けることで実装候補を同一ファイルに閉じ込められ、コンパイラの網羅性チェックが効くようになります。
+
+## 7.6 テスト
+
+`TypeSpec` では各タイプとファクトリメソッドを検証しています。
+
+```scala
+class TypeSpec extends AnyFunSuite:
+  test("Type01: 3 の倍数で Fizz を返す") {
+    assert(FizzBuzzType.Type01.generate(3) === "Fizz")
+  }
+
+  test("Type02: 15 を渡すと 15 を返す") {
+    assert(FizzBuzzType.Type02.generate(15) === "15")
+  }
+
+  test("Type03: 15 の倍数で FizzBuzz を返す") {
+    assert(FizzBuzzType.Type03.generate(15) === "FizzBuzz")
+  }
+
+  test("create: 未定義のタイプで例外が発生する") {
+    assertThrows[IllegalArgumentException] {
+      FizzBuzzType.create(4)
+    }
+  }
+```
+
+タイプごとの振る舞いを個別に固定することで、追加仕様時の回帰を防げます。
+
+## 7.7 まとめ
+
+この章では、`case class` と `trait` を使って FizzBuzz の型安全な設計を行いました。
+
+- `FizzBuzzValue` で値を明示的に表現
+- `FizzBuzzList` でコレクション操作をカプセル化
+- `FizzBuzzType` のポリモーフィズムでタイプ差分を分離
+
+次章では、`match` と `sealed trait` をさらに掘り下げ、Scala らしい分岐設計を整理します。

package/lib/assets/docs/article/getting-start-tdd/scala/08-pattern-matching-and-sealed-traits.md

@@ -0,0 +1,106 @@
+# 第 8 章: パターンマッチとシールドトレイト
+
+## 8.1 はじめに
+
+Scala の `match` は単なる `switch` の置き換えではなく、型と条件を統合して表現できる強力な構文です。`sealed trait` と組み合わせると、代数的データ型（ADT）として安全に分岐を記述できます。
+
+この章では、FizzBuzz のタイプ生成と変換ロジックを題材に、パターンマッチの基本と網羅性チェックを確認します。
+
+## 8.2 パターンマッチの基本
+
+`match/case` の基本構文は次のとおりです。
+
+```scala
+def generate(number: Int): String =
+  number match
+    case n if n % 15 == 0 => "FizzBuzz"
+    case n if n % 3 == 0  => "Fizz"
+    case n if n % 5 == 0  => "Buzz"
+    case n                => n.toString
+```
+
+重要な要素は 3 つです。
+
+- `match/case` で分岐を宣言的に記述できる
+- `case n if ...` のガード条件で複合条件を自然に表現できる
+- `case _` や `case n` でワイルドカード／フォールバックを定義できる
+
+## 8.3 シールドトレイトと網羅性
+
+`sealed trait` は「この抽象型の実装は同一ファイル内に限定する」という制約を与えます。
+
+```scala
+sealed trait FizzBuzzType:
+  def generate(number: Int): String
+```
+
+この制約により、コンパイラは次を支援できます。
+
+- 実装候補を把握し、網羅性を検証できる
+- `match` で未処理ケースがあると警告できる
+- 将来の型追加時に、分岐漏れを早期に検知できる
+
+`sealed trait` は ADT を安全に扱うための土台です。
+
+## 8.4 ファクトリメソッド
+
+タイプ番号から `FizzBuzzType` を生成する実装です。
+
+```scala
+def create(typeNumber: Int): FizzBuzzType =
+  typeNumber match
+    case 1 => Type01
+    case 2 => Type02
+    case 3 => Type03
+    case _ => throw IllegalArgumentException(s"未定義のタイプ: $typeNumber")
+```
+
+生成責務を `FizzBuzzType.create` に集約することで、呼び出し側は型番号の解釈を意識せずに済みます。
+
+## 8.5 Strategy パターンとの対応
+
+OOP の Strategy パターンでは、アルゴリズムをインターフェースで抽象化し、実行時に具象実装を差し替えます。
+
+FizzBuzz では次の対応になります。
+
+- Strategy の抽象: `FizzBuzzType`（`sealed trait`）
+- 具体 Strategy: `Type01` / `Type02` / `Type03`
+- Strategy 選択: `FizzBuzzType.create(typeNumber)`
+
+この構成により、呼び出し側の条件分岐を排除し、ポリモーフィズムで振る舞いを切り替えられます。
+
+## 8.6 テスト
+
+ファクトリメソッドは `TypeSpec` で次のように検証しています。
+
+```scala
+test("create: タイプ 1 を生成できる") {
+  assert(FizzBuzzType.create(1) === FizzBuzzType.Type01)
+}
+
+test("create: タイプ 2 を生成できる") {
+  assert(FizzBuzzType.create(2) === FizzBuzzType.Type02)
+}
+
+test("create: タイプ 3 を生成できる") {
+  assert(FizzBuzzType.create(3) === FizzBuzzType.Type03)
+}
+
+test("create: 未定義のタイプで例外が発生する") {
+  assertThrows[IllegalArgumentException] {
+    FizzBuzzType.create(4)
+  }
+}
+```
+
+正常系と異常系を両方固定することで、生成ルールの変更に対して安全にリファクタリングできます。
+
+## 8.7 まとめ
+
+この章では、Scala のパターンマッチと `sealed trait` の組み合わせを確認しました。
+
+- `match/case` とガード条件で分岐を明確化
+- `sealed trait` で実装範囲を制約し、網羅性チェックを有効化
+- `create` ファクトリで Strategy の切り替えを一元化
+
+次章では、ここまで作成したドメインモデルをパッケージ単位で整理し、モジュール設計としてまとめます。

package/lib/assets/docs/article/getting-start-tdd/scala/09-packages-and-module-design.md

@@ -0,0 +1,75 @@
+# 第 9 章: パッケージとモジュール設計
+
+## 9.1 はじめに
+
+クラスが増えると、実装の正しさだけでなく「どこに何を書くか」が品質に直結します。この章では、FizzBuzz のコードを題材に、責務ごとに整理するモジュール設計を確認します。
+
+## 9.2 パッケージ構成
+
+現在の Scala 実装は次の構成です。
+
+```text
+fizzbuzz/
+├── FizzBuzz.scala          (公開 API)
+├── domain/
+│   ├── Type.scala          (ドメインタイプ)
+│   └── Model.scala         (値オブジェクト)
+└── application/
+    └── Command.scala       (コマンドパターン)
+```
+
+`domain` と `application` を分離することで、ビジネスルールとユースケース実行を明確に切り分けています。
+
+## 9.3 ドメイン層
+
+ドメイン層は「FizzBuzz として何が正しいか」を表現する層です。
+
+- `domain.Type`: 変換ルール（Type01/02/03）とファクトリメソッド
+- `domain.Model`: 値オブジェクト `FizzBuzzValue` とファーストクラスコレクション `FizzBuzzList`
+
+`require` による事前条件や `sealed trait` による型制約をドメイン側に置くことで、不正な状態の侵入を早期に防げます。
+
+## 9.4 アプリケーション層
+
+アプリケーション層はユースケースを実行する層です。
+
+- `application.Command`: `FizzBuzzCommand` と具象コマンド
+- `FizzBuzzValueCommand`: 単一値を返すユースケース
+- `FizzBuzzListCommand`: 複数値を改行区切り文字列として返すユースケース
+
+アプリケーション層は `domain` を利用しますが、`domain` は `application` に依存しません。この依存方向により、ビジネスルールを独立して保守できます。
+
+## 9.5 Command パターン
+
+`Command.scala` の中心となる実装です。
+
+```scala
+trait FizzBuzzCommand:
+  def execute(): String
+
+class FizzBuzzValueCommand(number: Int, typeNumber: Int) extends FizzBuzzCommand:
+  def execute(): String =
+    val fizzBuzzType = FizzBuzzType.create(typeNumber)
+    val value = FizzBuzzValue(number, fizzBuzzType.generate(number))
+    value.toString
+```
+
+同じインターフェース（`execute`）で操作を抽象化し、呼び出し側はコマンドの差し替えだけで振る舞いを変更できます。
+
+## 9.6 SOLID 原則との対応
+
+この構成は SOLID 原則に次のように対応します。
+
+- 単一責任: `Type.scala` は変換ルール、`Model.scala` は値表現、`Command.scala` は実行手順に責務分離
+- 開放閉鎖: 新しいタイプは `FizzBuzzType` の実装追加で拡張しやすい
+- 依存性逆転: `trait FizzBuzzCommand` と `trait FizzBuzzType` による抽象化で依存を安定化
+
+## 9.7 まとめ
+
+この章では、FizzBuzz 実装をパッケージ単位で整理し、モジュール設計の基本を確認しました。
+
+- `domain` にビジネスルールを集約
+- `application` にユースケース実行を集約
+- `trait` を軸に依存関係をシンプルに保つ
+
+第 3 部でオブジェクト指向設計の基盤が整ったので、次の第 4 部では関数型プログラミングの要素を取り入れて設計をさらに発展させます。

package/lib/assets/docs/article/getting-start-tdd/scala/10-higher-order-functions-and-composition.md

@@ -0,0 +1,104 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+第 3 部ではケースクラスやトレイトを使って OOP の基礎を整理しました。第 4 部では Scala の関数型プログラミング（FP）に焦点を当てます。
+
+Scala では関数は第一級オブジェクトです。関数を変数に代入でき、引数として渡せて、戻り値として返せます。この性質により、柔軟で再利用しやすい実装が可能になります。
+
+## 10.2 高階関数
+
+高階関数は「関数を引数に取る、または関数を返す関数」です。`generateWith` は最小構成の例です。
+
+```scala
+def generateWith(rule: Int => String)(number: Int): String =
+  rule(number)
+```
+
+このメソッドは 2 つのパラメータリストを持つカリー化された形です。
+
+- 第 1 パラメータリスト: `rule`（`Int => String`）
+- 第 2 パラメータリスト: `number`（`Int`）
+
+使い方の例です。
+
+```scala
+val customRule: Int => String = n => if n % 2 == 0 then "Even" else "Odd"
+val generator = FizzBuzz.generateWith(customRule)
+
+assert(generator(2) == "Even")
+assert(generator(3) == "Odd")
+```
+
+`val generator = FizzBuzz.generateWith(customRule)` は部分適用です。ルールだけ先に固定し、後から数値だけ渡せるようになります。
+
+## 10.3 コレクション操作
+
+Scala のコレクションは `map`、`filter`、`reduce` のような高階関数を標準で備えています。
+
+- `map`: 各要素を変換する
+- `filter`: 条件に一致する要素だけ残す
+- `reduce`: 要素を 1 つの値に畳み込む
+
+FizzBuzz の実装では、`transform` と `filter` でこの考え方をそのまま表現しています。
+
+```scala
+def transform(values: List[String], f: String => String): List[String] =
+  values.map(f)
+
+def filter(values: List[String], predicate: String => Boolean): List[String] =
+  values.filter(predicate)
+```
+
+`transform` は変換ロジックを引数で受け取るため、`toUpperCase` 以外にも自由に差し替えできます。
+
+## 10.4 関数合成
+
+複数の小さな関数を組み合わせて新しい関数を作るのが関数合成です。実装は次のとおりです。
+
+```scala
+def compose(f: String => String, g: String => String): String => String =
+  f.compose(g)
+```
+
+`f.compose(g)` は `f(g(x))` を意味します。つまり右から左へ適用されます。対して `andThen` は `g(f(x))` で、左から右へ適用されます。
+
+```scala
+val addBrackets: String => String = s => s"[$s]"
+val toUpper: String => String = _.toUpperCase
+
+val composed = addBrackets.compose(toUpper) // addBrackets(toUpper(x))
+val piped = addBrackets.andThen(toUpper)    // toUpper(addBrackets(x))
+```
+
+この違いを理解すると、パイプライン処理を意図通りに組み立てられます。
+
+## 10.5 テスト
+
+実装した関数型メソッドは、次のようにテストできます。
+
+```scala
+test("generateWith: カスタムルールで生成する") {
+  val customRule: Int => String = n => if n % 2 == 0 then "Even" else "Odd"
+  assert(FizzBuzz.generateWith(customRule)(2) === "Even")
+}
+
+test("compose: 2 つの関数を合成する") {
+  val addBrackets: String => String = s => s"[$s]"
+  val toUpper: String => String = _.toUpperCase
+  val combined = FizzBuzz.compose(addBrackets, toUpper)
+  assert(combined("Fizz") === "[FIZZ]")
+}
+```
+
+高階関数や関数合成は抽象度が上がるため、入力と出力を明示したテストが特に重要です。
+
+## 10.6 まとめ
+
+この章では、Scala の関数型プログラミングの入口として次を確認しました。
+
+- 高階関数 `generateWith` とカリー化
+- `map`、`filter` を使うコレクション操作
+- `compose` と `andThen` の違い
+
+次章では、コレクション処理をさらに発展させ、`LazyList` による遅延評価を扱います。

package/lib/assets/docs/article/getting-start-tdd/scala/11-collections-and-lazy-evaluation.md

@@ -0,0 +1,94 @@
+# 第 11 章: コレクション処理と遅延評価
+
+## 11.1 はじめに
+
+Scala の強みの 1 つは、表現力の高いコレクションライブラリです。`List` や `Vector` を使った宣言的な処理により、ループ中心の実装より意図を明確に書けます。
+
+ここで重要なのが評価戦略です。
+
+- 正格評価（eager evaluation）: すぐに計算する
+- 遅延評価（lazy evaluation）: 必要になるまで計算しない
+
+## 11.2 イミュータブルコレクション
+
+Scala の標準コレクションは、デフォルトでイミュータブルを前提に設計されています。
+
+- `List`: 連結リスト。先頭追加や再帰的処理と相性がよい
+- `Vector`: ランダムアクセスに強い
+- `Map`: キーと値の対応
+- `Set`: 重複しない集合
+
+イミュータブルな設計により、副作用を抑えやすくなり、テストしやすいコードになります。
+
+## 11.3 コレクション操作の連鎖
+
+`map`、`flatMap`、`filter`、`foldLeft` を連鎖させると、データ変換の流れを自然に表現できます。
+
+```scala
+val numbers = (1 to 20).toList
+val result = numbers
+  .map(FizzBuzz.generate)
+  .filter(_ != "FizzBuzz")
+  .foldLeft(List.empty[String])((acc, v) => acc :+ v)
+```
+
+for 内包表記も同じ考え方で使えます。
+
+```scala
+val result = for
+  n <- 1 to 100
+  value = FizzBuzz.generate(n)
+  if value != n.toString
+yield value
+```
+
+for 内包表記は、`map`、`flatMap`、`filter` の組み合わせを読みやすく書くための構文糖衣です。
+
+## 11.4 LazyList による遅延評価
+
+FizzBuzz では無限シーケンスを `LazyList` で表現できます。
+
+```scala
+def lazyList: LazyList[String] =
+  LazyList.from(1).map(generate)
+```
+
+`LazyList.from(1)` は 1 から始まる無限列です。`map(generate)` を付けても、実際の計算は要素を取り出すまで実行されません。
+
+```scala
+val firstFive = FizzBuzz.lazyList.take(5).toList
+// List("1", "2", "Fizz", "4", "Buzz")
+```
+
+遅延評価の利点は次のとおりです。
+
+- 必要な分だけ計算するため無駄が少ない
+- 無限リストを安全に表現できる
+- `take`、`drop`、`filter` を組み合わせた逐次処理を書きやすい
+
+## 11.5 テスト
+
+`LazyList` は「必要なときだけ評価される」ことを確認するテストが重要です。
+
+```scala
+test("lazyList: 遅延リストから最初の 5 要素を取得する") {
+  val result = FizzBuzz.lazyList.take(5).toList
+  assert(result === List("1", "2", "Fizz", "4", "Buzz"))
+}
+
+test("lazyList: 遅延リストから 15 番目の要素を取得する") {
+  assert(FizzBuzz.lazyList(14) === "FizzBuzz")
+}
+```
+
+先頭数件だけを取り出すテストと、任意の位置の要素を直接参照するテストを組み合わせると、遅延シーケンスの振る舞いを網羅できます。
+
+## 11.6 まとめ
+
+この章では、Scala のコレクション処理と遅延評価を確認しました。
+
+- イミュータブルコレクションを前提に実装する
+- `map`、`flatMap`、`filter`、`foldLeft` を連鎖して処理を記述する
+- `LazyList` で無限シーケンスと必要時評価を実現する
+
+次章では、`Option` や `Either` を使った型安全なエラーハンドリングを扱います。

package/lib/assets/docs/article/getting-start-tdd/scala/12-error-handling-and-type-safety.md

@@ -0,0 +1,92 @@
+# 第 12 章: エラーハンドリングと型安全性
+
+## 12.1 はじめに
+
+Scala では、例外を多用するよりも型でエラー可能性を表現する設計が推奨されます。コンパイル時に考慮漏れを減らせるためです。
+
+この章では `Option`、`Either`、`Try`、`require` を使い、型安全なエラーハンドリングを整理します。
+
+## 12.2 Option 型
+
+`Option` は「値があるかもしれないし、ないかもしれない」を表現します。
+
+```scala
+def safeGenerate(number: Int): Option[String] =
+  if number > 0 then Some(generate(number))
+  else None
+```
+
+- `Some(value)`: 値あり
+- `None`: 値なし
+
+`Option` は `map`、`flatMap`、`getOrElse` と相性がよく、null チェックを置き換えられます。
+
+```scala
+val message = FizzBuzz.safeGenerate(3)
+  .map(v => s"結果: $v")
+  .getOrElse("入力が不正です")
+```
+
+## 12.3 Either 型
+
+`Either` は成功と失敗のどちらかを保持します。
+
+```scala
+def generateEither(number: Int): Either[String, String] =
+  if number > 0 then Right(generate(number))
+  else Left(s"正の整数が必要です: $number")
+```
+
+- `Right`: 成功値
+- `Left`: エラー情報
+
+`Either` を使うと、エラーを文字列やドメイン型で返せるため、例外より制御しやすくなります。複数処理の連鎖では for 内包表記も利用できます。
+
+```scala
+val result = for
+  a <- FizzBuzz.generateEither(3)
+  b <- FizzBuzz.generateEither(5)
+yield s"$a, $b"
+```
+
+## 12.4 Try 型
+
+`Try` は例外を値として扱う型です。例外が起きうる処理を安全に包めます。
+
+```scala
+import scala.util.Try
+
+val parsed: Try[Int] = Try("42".toInt)
+```
+
+`Try` は `Success` / `Failure` の 2 形です。`map` や `recover` と組み合わせると、例外処理を宣言的に記述できます。
+
+## 12.5 require による事前条件
+
+ドメインモデルの入力検証には `require` が使えます。
+
+```scala
+case class FizzBuzzValue(number: Int, value: String):
+  require(number > 0, s"数値は正の整数でなければなりません: $number")
+```
+
+不正な値でオブジェクトが作られることを防ぎ、ドメイン不変条件をコンストラクタ境界で守れます。
+
+## 12.6 型安全な設計のまとめ
+
+- `Option`: 値の有無を型で表現する
+- `Either`: 成功 / 失敗の分岐を型で表現する
+- `Try`: 例外を値として安全に扱う
+- `require`: 事前条件を明示し、不正状態を早期に排除する
+
+## 12.7 シリーズのまとめ
+
+全 12 章を通して、FizzBuzz を題材に TDD と Scala の設計原則を段階的に学びました。
+
+- TDD の基本サイクル（Red-Green-Refactor）
+- 開発環境の自動化
+- オブジェクト指向設計（ケースクラス、トレイト、パターンマッチ）
+- 関数型プログラミング（高階関数、コレクション、型安全なエラーハンドリング）
+- Scala の OOP と FP の統合
+
+小さな題材でも、設計・テスト・リファクタリングを繰り返すことで、実務で使える設計力を着実に伸ばせます。

package/lib/assets/docs/article/getting-start-tdd/scala/index.md

@@ -0,0 +1,65 @@
+# テスト駆動開発から始める Scala 入門
+
+## 概要
+
+本シリーズでは、テスト駆動開発（TDD）の実践を通じて Scala の特徴を学びます。FizzBuzz 問題を題材に、Red-Green-Refactor サイクルを体験しながら、Scala のオブジェクト指向と関数型プログラミングの両方を段階的に習得します。
+
+## 対象読者
+
+- プログラミングの基礎知識を持つ方
+- TDD に興味がある方
+- Scala や JVM 上の関数型プログラミングに興味がある方
+
+## 前提条件
+
+- Scala 3.x、sbt がインストールされていること
+- テキストエディタまたは IDE が利用可能であること
+- Git の基本操作ができること
+
+## Scala の特徴
+
+| 特徴 | 説明 |
+|------|------|
+| OOP と FP の統合 | オブジェクト指向と関数型プログラミングを自然に組み合わせ可能 |
+| 型推論 | 強力な型推論により型アノテーションを最小限に抑制 |
+| ケースクラス | 不変の値オブジェクトを簡潔に定義 |
+| パターンマッチ | 網羅的で型安全な分岐処理 |
+| トレイト | 柔軟なミックスインによるコード再利用 |
+| コレクションライブラリ | 統一的な API による豊富なコレクション操作 |
+| JVM 互換 | Java エコシステムとの完全な相互運用性 |
+
+## 開発ツール
+
+| ツール | 用途 |
+|--------|------|
+| sbt | ビルドツール・パッケージマネージャ |
+| ScalaTest | テスティングフレームワーク |
+| scalafmt | コードフォーマッタ |
+| WartRemover | 静的解析（コード品質チェック） |
+| Metals | Language Server Protocol 実装 |
+
+## 目次
+
+### 第 1 部: TDD の基本サイクル
+
+1. [第 1 章: TODO リストと最初のテスト](./01-todo-list-and-first-test.md)
+2. [第 2 章: 仮実装と三角測量](./02-fake-it-and-triangulation.md)
+3. [第 3 章: 明白な実装とリファクタリング](./03-obvious-implementation-and-refactoring.md)
+
+### 第 2 部: 開発環境と自動化
+
+4. [第 4 章: バージョン管理と Conventional Commits](./04-version-control-and-conventional-commits.md)
+5. [第 5 章: パッケージ管理と静的解析](./05-package-management-and-static-analysis.md)
+6. [第 6 章: タスクランナーと CI/CD](./06-task-runner-and-ci-cd.md)
+
+### 第 3 部: オブジェクト指向設計
+
+7. [第 7 章: ケースクラスとトレイトによるポリモーフィズム](./07-case-classes-and-traits.md)
+8. [第 8 章: パターンマッチとシールドトレイト](./08-pattern-matching-and-sealed-traits.md)
+9. [第 9 章: パッケージとモジュール設計](./09-packages-and-module-design.md)
+
+### 第 4 部: 関数型プログラミング
+
+10. [第 10 章: 高階関数と関数合成](./10-higher-order-functions-and-composition.md)
+11. [第 11 章: コレクション処理と遅延評価](./11-collections-and-lazy-evaluation.md)
+12. [第 12 章: エラーハンドリングと型安全性](./12-error-handling-and-type-safety.md)