@k2works/claude-code-booster 4.8.0 → 4.11.0

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

@@ -1,106 +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 の切り替えを一元化
-
-次章では、ここまで作成したドメインモデルをパッケージ単位で整理し、モジュール設計としてまとめます。
+# 第 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

@@ -1,75 +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 部では関数型プログラミングの要素を取り入れて設計をさらに発展させます。
+# 第 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

@@ -1,104 +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` による遅延評価を扱います。
+# 第 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` による遅延評価を扱います。