@k2works/claude-code-booster 4.13.0 → 4.15.0

package/lib/assets/docs/article/grokkingfp/scala/part-6.md

@@ -1,867 +1,867 @@
-# Part VI: 実践的なアプリケーション構築とテスト
-
-本章では、これまで学んだ関数型プログラミングの概念を統合し、実践的なアプリケーションを構築します。また、関数型プログラミングにおけるテスト戦略についても学びます。
-
----
-
-## 第11章: 実践的なアプリケーション構築
-
-### 11.1 TravelGuide アプリケーション
-
-旅行ガイドアプリケーションを例に、実践的な FP アプリケーションの構築方法を学びます。
-
-```plantuml
-@startuml
-!theme plain
-
-package "TravelGuide Application" {
-  rectangle "Model" {
-    class Location {
-      id: LocationId
-      name: String
-      population: Int
-    }
-
-    class Attraction {
-      name: String
-      description: Option[String]
-      location: Location
-    }
-
-    class TravelGuide {
-      attraction: Attraction
-      subjects: List[String]
-    }
-  }
-
-  rectangle "Data Access" {
-    interface DataAccess {
-      +findAttractions(): IO[List[Attraction]]
-      +findArtistsFromLocation(): IO[List[MusicArtist]]
-      +findMoviesAboutLocation(): IO[List[Movie]]
-    }
-
-    class WikidataDataAccess
-    class CachedDataAccess
-  }
-
-  DataAccess <|.. WikidataDataAccess
-  DataAccess <|.. CachedDataAccess
-}
-
-@enduml
-```
-
-### 11.2 ドメインモデルの定義
-
-**ソースファイル**: `app/scala/src/main/scala/ch11_TravelGuide.scala`
-
-```scala
-// 位置情報を表す値オブジェクト
-opaque type LocationId = String
-object LocationId {
-  def apply(value: String): LocationId = value
-  extension (a: LocationId) def value: String = a
-}
-
-// ロケーション
-case class Location(id: LocationId, name: String, population: Int)
-
-// アトラクション（観光地）
-case class Attraction(
-    name: String,
-    description: Option[String],
-    location: Location
-)
-
-// 旅行ガイド
-case class TravelGuide(attraction: Attraction, subjects: List[String])
-```
-
-### 11.3 データアクセス層の抽象化
-
-外部データソースへのアクセスをトレイトで抽象化します。
-
-```scala
-trait DataAccess {
-  def findAttractions(
-      name: String,
-      ordering: AttractionOrdering,
-      limit: Int
-  ): IO[List[Attraction]]
-
-  def findArtistsFromLocation(
-      locationId: LocationId,
-      limit: Int
-  ): IO[List[MusicArtist]]
-
-  def findMoviesAboutLocation(
-      locationId: LocationId,
-      limit: Int
-  ): IO[List[Movie]]
-}
-```
-
-```plantuml
-@startuml
-!theme plain
-
-interface DataAccess {
-  +findAttractions(): IO[List[Attraction]]
-  +findArtistsFromLocation(): IO[List[MusicArtist]]
-  +findMoviesAboutLocation(): IO[List[Movie]]
-}
-
-note right of DataAccess
-  純粋な関数型インターフェース
-  すべての操作は IO でラップ
-end note
-
-class WikidataDataAccess {
-  -sparqlEndpoint: String
-  +findAttractions(): IO[List[Attraction]]
-  +findArtistsFromLocation(): IO[List[MusicArtist]]
-  +findMoviesAboutLocation(): IO[List[Movie]]
-}
-
-class TestDataAccess {
-  -testData: Map[String, List[Attraction]]
-  +findAttractions(): IO[List[Attraction]]
-  +findArtistsFromLocation(): IO[List[MusicArtist]]
-  +findMoviesAboutLocation(): IO[List[Movie]]
-}
-
-DataAccess <|.. WikidataDataAccess
-DataAccess <|.. TestDataAccess
-
-@enduml
-```
-
-### 11.4 Resource によるリソース管理
-
-cats-effect の `Resource` を使用して、安全なリソース管理を実現します。
-
-**ソースファイル**: `app/scala/src/main/scala/ch11_TravelGuide.scala`
-
-```scala
-def execQuery(
-    query: String
-): Resource[IO, List[QuerySolution]] = {
-  val connection: Resource[IO, RDFConnection] =
-    Resource.make(
-      IO.blocking(
-        RDFConnectionRemote
-          .create()
-          .destination(WikidataSparqlEndpoint)
-          .build()
-      )
-    )(connection => IO.blocking(connection.close()))
-
-  for {
-    conn   <- connection
-    result <- Resource.eval(IO.blocking {
-      val resultSet = conn.query(query).execSelect()
-      resultSet.asScala.toList
-    })
-  } yield result
-}
-```
-
-```plantuml
-@startuml
-!theme plain
-
-participant "Application" as app
-participant "Resource" as res
-participant "RDFConnection" as conn
-participant "SPARQL Endpoint" as sparql
-
-app -> res: Resource.make(acquire)(release)
-res -> conn: acquire: IO.blocking(create())
-conn -> sparql: connect
-sparql --> conn: connection
-
-app -> res: use (query execution)
-res -> conn: query.execSelect()
-conn -> sparql: SPARQL query
-sparql --> conn: results
-conn --> res: List[QuerySolution]
-res --> app: results
-
-app -> res: release (automatic)
-res -> conn: IO.blocking(close())
-conn -> sparql: disconnect
-
-note over res
-  Resource は例外が発生しても
-  必ず release を実行する
-end note
-
-@enduml
-```
-
-### 11.5 キャッシュの実装
-
-`Ref` を使用したスレッドセーフなキャッシュの実装:
-
-```scala
-def cachedAttractions(
-    dataAccess: DataAccess
-): IO[DataAccess] = {
-  for {
-    cache <- Ref.of[IO, Map[String, List[Attraction]]](Map.empty)
-  } yield new DataAccess {
-    def findAttractions(
-        name: String,
-        ordering: AttractionOrdering,
-        limit: Int
-    ): IO[List[Attraction]] = {
-      val key = s"$name-$ordering-$limit"
-      for {
-        cached <- cache.get.map(_.get(key))
-        result <- cached match {
-          case Some(attractions) => IO.pure(attractions)
-          case None =>
-            for {
-              attractions <- dataAccess.findAttractions(name, ordering, limit)
-              _           <- cache.update(_ + (key -> attractions))
-            } yield attractions
-        }
-      } yield result
-    }
-
-    // 他のメソッドも同様に実装...
-  }
-}
-```
-
-```plantuml
-@startuml
-!theme plain
-skinparam activity {
-  BackgroundColor White
-  BorderColor Black
-}
-
-start
-
-:キャッシュキー生成;
-
-:cache.get でキャッシュ確認;
-
-if (キャッシュにデータあり?) then (yes)
-  :キャッシュからデータ返却;
-else (no)
-  :外部 API を呼び出し;
-  :結果をキャッシュに保存;
-  :結果を返却;
-endif
-
-stop
-
-note right
-  Ref を使用した
-  スレッドセーフなキャッシュ
-end note
-
-@enduml
-```
-
-### 11.6 アプリケーションの組み立て
-
-すべてのコンポーネントを組み合わせてアプリケーションを構築します。
-
-```scala
-def travelGuide(data: DataAccess, attractionName: String): IO[Option[TravelGuide]] = {
-  for {
-    attractions <- data.findAttractions(attractionName, ByLocationPopulation, 1)
-    guide <- attractions.headOption match {
-      case None => IO.pure(None)
-      case Some(attraction) =>
-        for {
-          artists <- data.findArtistsFromLocation(attraction.location.id, 2)
-          movies  <- data.findMoviesAboutLocation(attraction.location.id, 2)
-        } yield Some(
-          TravelGuide(
-            attraction,
-            artists.map(_.name) ++ movies.map(_.name)
-          )
-        )
-    }
-  } yield guide
-}
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "travelGuide 関数" {
-  card "1. アトラクション検索" as step1
-  card "2. アーティスト検索" as step2
-  card "3. 映画検索" as step3
-  card "4. TravelGuide 組み立て" as step4
-
-  step1 --> step2 : attraction
-  step1 --> step3 : location.id
-  step2 --> step4 : artists
-  step3 --> step4 : movies
-}
-
-note bottom
-  for 内包表記で
-  複数の IO を合成
-end note
-
-@enduml
-```
-
----
-
-## 第12章: テスト戦略
-
-### 12.1 関数型プログラミングのテスト
-
-関数型プログラミングでは、純粋関数のおかげでテストが非常に簡単になります。
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "テストの種類" {
-  rectangle "単体テスト" as unit {
-    card "純粋関数のテスト"
-    card "高速・独立"
-  }
-
-  rectangle "プロパティベーステスト" as property {
-    card "ランダム入力"
-    card "不変条件の検証"
-  }
-
-  rectangle "統合テスト" as integration {
-    card "コンポーネント連携"
-    card "スタブ/モック使用"
-  }
-}
-
-unit --> property : 補完
-property --> integration : 補完
-
-@enduml
-```
-
-### 12.2 SearchReport の導入
-
-**ソースファイル**: `app/scala/src/main/scala/ch12_TravelGuide.scala`
-
-テスト可能性を高めるため、`SearchReport` を導入します。
-
-```scala
-case class SearchReport(
-    attractionsSearched: Int,
-    errors: List[String]
-)
-
-case class TravelGuide(
-    attraction: Attraction,
-    subjects: List[String],
-    searchReport: SearchReport
-)
-```
-
-```plantuml
-@startuml
-!theme plain
-
-class TravelGuide {
-  attraction: Attraction
-  subjects: List[String]
-  searchReport: SearchReport
-}
-
-class SearchReport {
-  attractionsSearched: Int
-  errors: List[String]
-}
-
-TravelGuide --> SearchReport
-
-note right of SearchReport
-  検索の統計情報と
-  エラー情報を保持
-end note
-
-@enduml
-```
-
-### 12.3 エラーハンドリングの改善
-
-```scala
-def findArtistsFromLocation(
-    locationId: LocationId,
-    limit: Int
-): IO[Either[String, List[MusicArtist]]]
-
-def findMoviesAboutLocation(
-    locationId: LocationId,
-    limit: Int
-): IO[Either[String, List[Movie]]]
-```
-
-Either を使用してエラーを明示的に扱います:
-
-```scala
-def travelGuide(
-    data: DataAccess,
-    attractionName: String
-): IO[Option[TravelGuide]] = {
-  for {
-    attractions <- data.findAttractions(attractionName, ByLocationPopulation, 3)
-    guides <- attractions.traverse { attraction =>
-      for {
-        artistsResult <- data.findArtistsFromLocation(attraction.location.id, 2)
-        moviesResult  <- data.findMoviesAboutLocation(attraction.location.id, 2)
-      } yield {
-        val errors = List(artistsResult, moviesResult).collect {
-          case Left(error) => error
-        }
-        val artists = artistsResult.getOrElse(Nil)
-        val movies = moviesResult.getOrElse(Nil)
-        TravelGuide(
-          attraction,
-          artists.map(_.name) ++ movies.map(_.name),
-          SearchReport(attractions.size, errors)
-        )
-      }
-    }
-  } yield guides.headOption
-}
-```
-
-### 12.4 スタブを使用したテスト
-
-**ソースファイル**: `app/scala/src/main/scala/ch12_TravelGuideTest.scala`
-
-```scala
-// テスト用のスタブ実装
-val testDataAccess: DataAccess = new DataAccess {
-  def findAttractions(
-      name: String,
-      ordering: AttractionOrdering,
-      limit: Int
-  ): IO[List[Attraction]] = IO.pure(
-    List(
-      Attraction(
-        "Test Attraction",
-        Some("A test attraction"),
-        Location(LocationId("Q123"), "Test City", 100000)
-      )
-    )
-  )
-
-  def findArtistsFromLocation(
-      locationId: LocationId,
-      limit: Int
-  ): IO[Either[String, List[MusicArtist]]] =
-    IO.pure(Right(List(MusicArtist("Test Artist"))))
-
-  def findMoviesAboutLocation(
-      locationId: LocationId,
-      limit: Int
-  ): IO[Either[String, List[Movie]]] =
-    IO.pure(Right(List(Movie("Test Movie"))))
-}
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "テスト構成" {
-  rectangle "本番" as prod {
-    interface "DataAccess" as da1
-    class "WikidataDataAccess" as wda
-    da1 <|.. wda
-  }
-
-  rectangle "テスト" as test {
-    interface "DataAccess" as da2
-    class "TestDataAccess" as tda
-    da2 <|.. tda
-  }
-}
-
-note bottom of prod
-  実際の Wikidata に接続
-end note
-
-note bottom of test
-  テストデータを返す
-  IO.pure で即座に結果を返す
-end note
-
-@enduml
-```
-
-### 12.5 プロパティベーステスト
-
-ScalaCheck を使用したプロパティベーステスト:
-
-```scala
-import org.scalacheck.Gen
-import org.scalacheck.Prop.forAll
-
-// ジェネレータの定義
-val locationIdGen: Gen[LocationId] =
-  Gen.alphaNumStr.map(LocationId.apply)
-
-val locationGen: Gen[Location] = for {
-  id         <- locationIdGen
-  name       <- Gen.alphaStr
-  population <- Gen.posNum[Int]
-} yield Location(id, name, population)
-
-val attractionGen: Gen[Attraction] = for {
-  name        <- Gen.alphaStr
-  description <- Gen.option(Gen.alphaStr)
-  location    <- locationGen
-} yield Attraction(name, description, location)
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "プロパティベーステスト" {
-  card "Gen[A]" as gen
-  card "ランダムデータ生成" as random
-  card "プロパティ検証" as verify
-  card "100回以上テスト" as repeat
-
-  gen --> random
-  random --> verify
-  verify --> repeat
-  repeat --> random : 繰り返し
-}
-
-note bottom
-  ランダムな入力で
-  不変条件を検証
-end note
-
-@enduml
-```
-
-### 12.6 不変条件のテスト
-
-```scala
-// プロパティ: アトラクションの数は limit 以下
-property("findAttractions returns at most limit attractions") =
-  forAll(Gen.alphaStr, Gen.posNum[Int]) { (name: String, limit: Int) =>
-    val result = dataAccess
-      .findAttractions(name, ByLocationPopulation, limit)
-      .unsafeRunSync()
-    result.size <= limit
-  }
-
-// プロパティ: SearchReport のエラー数は検索数以下
-property("SearchReport errors are bounded by searches") =
-  forAll(attractionGen) { attraction =>
-    val guide = travelGuide(testDataAccess, attraction.name).unsafeRunSync()
-    guide.forall { g =>
-      g.searchReport.errors.size <= 2 // artists + movies
-    }
-  }
-```
-
-### 12.7 統合テスト
-
-```scala
-// 統合テスト: エンドツーエンドのシナリオ
-test("travelGuide returns guide for valid attraction") {
-  val result = travelGuide(testDataAccess, "Test").unsafeRunSync()
-
-  assert(result.isDefined)
-  result.foreach { guide =>
-    assert(guide.attraction.name == "Test Attraction")
-    assert(guide.subjects.nonEmpty)
-    assert(guide.searchReport.errors.isEmpty)
-  }
-}
-
-// エラーケースのテスト
-test("travelGuide handles errors gracefully") {
-  val failingDataAccess = new DataAccess {
-    def findAttractions(name: String, ordering: AttractionOrdering, limit: Int) =
-      IO.pure(List(testAttraction))
-
-    def findArtistsFromLocation(locationId: LocationId, limit: Int) =
-      IO.pure(Left("Network error"))
-
-    def findMoviesAboutLocation(locationId: LocationId, limit: Int) =
-      IO.pure(Left("Timeout"))
-  }
-
-  val result = travelGuide(failingDataAccess, "Test").unsafeRunSync()
-
-  assert(result.isDefined)
-  result.foreach { guide =>
-    assert(guide.searchReport.errors.size == 2)
-  }
-}
-```
-
-### 12.8 テストピラミッド
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "テストピラミッド" {
-  rectangle "E2E テスト\n(少数)" as e2e
-  rectangle "統合テスト\n(中程度)" as integration
-  rectangle "単体テスト + プロパティテスト\n(多数)" as unit
-}
-
-e2e -[hidden]down- integration
-integration -[hidden]down- unit
-
-note right of unit
-  FP では純粋関数が多いため
-  単体テストが非常に効果的
-end note
-
-@enduml
-```
-
----
-
-## まとめ
-
-### Part VI で学んだこと
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Part VI: 実践的なアプリケーション" {
-  rectangle "第11章" as ch11 {
-    card "ドメインモデル設計"
-    card "DataAccess 抽象化"
-    card "Resource 管理"
-    card "キャッシュ実装"
-  }
-
-  rectangle "第12章" as ch12 {
-    card "SearchReport"
-    card "スタブ/モック"
-    card "プロパティベーステスト"
-    card "統合テスト"
-  }
-}
-
-ch11 --> ch12
-
-@enduml
-```
-
-### キーポイント
-
-1. **抽象化の重要性**: DataAccess トレイトで外部依存を抽象化
-2. **Resource でリソース管理**: 安全なリソースの取得と解放
-3. **Ref でキャッシュ**: スレッドセーフな状態管理
-4. **Either でエラー処理**: 明示的なエラーハンドリング
-5. **SearchReport**: テスト可能性と可観測性の向上
-6. **スタブ**: 外部依存を差し替えてテスト
-7. **プロパティベーステスト**: ランダム入力で不変条件を検証
-
-### 学習の総括
-
-```plantuml
-@startuml
-!theme plain
-left to right direction
-
-rectangle "FP の学習パス" {
-  card "Part I\n基礎" as p1
-  card "Part II\nイミュータブル操作" as p2
-  card "Part III\n型による安全性" as p3
-  card "Part IV\nIO/Stream" as p4
-  card "Part V\n並行処理" as p5
-  card "Part VI\n実践" as p6
-}
-
-p1 --> p2
-p2 --> p3
-p3 --> p4
-p4 --> p5
-p5 --> p6
-
-@enduml
-```
-
----
-
-## 演習問題
-
-### 問題 1: DataAccess の拡張
-
-以下の要件で `DataAccess` を拡張してください:
-
-
-- 新しいメソッド `findHotelsNearLocation` を追加
-- 戻り値は `IO[Either[String, List[Hotel]]]`
-
-<details>
-<summary>解答</summary>
-
-```scala
-case class Hotel(name: String, rating: Double, location: Location)
-
-trait DataAccess {
-  // 既存のメソッド...
-
-  def findHotelsNearLocation(
-      locationId: LocationId,
-      limit: Int
-  ): IO[Either[String, List[Hotel]]]
-}
-
-// テスト用スタブ
-val testDataAccess: DataAccess = new DataAccess {
-  // 既存の実装...
-
-  def findHotelsNearLocation(
-      locationId: LocationId,
-      limit: Int
-  ): IO[Either[String, List[Hotel]]] =
-    IO.pure(Right(List(
-      Hotel("Test Hotel", 4.5, testLocation)
-    )))
-}
-```
-
-</details>
-
-### 問題 2: プロパティベーステスト
-
-以下の関数に対するプロパティベーステストを書いてください:
-
-```scala
-def filterPopularLocations(
-    locations: List[Location],
-    minPopulation: Int
-): List[Location] =
-  locations.filter(_.population >= minPopulation)
-```
-
-<details>
-<summary>解答</summary>
-
-```scala
-import org.scalacheck.Gen
-import org.scalacheck.Prop.forAll
-
-val locationGen: Gen[Location] = for {
-  id         <- Gen.alphaNumStr.map(LocationId.apply)
-  name       <- Gen.alphaStr
-  population <- Gen.chooseNum(0, 10000000)
-} yield Location(id, name, population)
-
-val locationsGen: Gen[List[Location]] =
-  Gen.listOf(locationGen)
-
-// プロパティ1: 結果は入力以下の要素数
-property("result size <= input size") =
-  forAll(locationsGen, Gen.posNum[Int]) {
-    (locations: List[Location], minPop: Int) =>
-      filterPopularLocations(locations, minPop).size <= locations.size
-  }
-
-// プロパティ2: 結果のすべての要素は条件を満たす
-property("all results meet minimum population") =
-  forAll(locationsGen, Gen.posNum[Int]) {
-    (locations: List[Location], minPop: Int) =>
-      filterPopularLocations(locations, minPop)
-        .forall(_.population >= minPop)
-  }
-
-// プロパティ3: 条件を満たす要素はすべて結果に含まれる
-property("all qualifying locations are in result") =
-  forAll(locationsGen, Gen.posNum[Int]) {
-    (locations: List[Location], minPop: Int) =>
-      val result = filterPopularLocations(locations, minPop)
-      locations.filter(_.population >= minPop).forall(result.contains)
-  }
-```
-
-</details>
-
-### 問題 3: Resource の実装
-
-ファイルを安全に読み取る `Resource` を実装してください。
-
-<details>
-<summary>解答</summary>
-
-```scala
-import cats.effect.{IO, Resource}
-import java.io.{BufferedReader, FileReader}
-
-def fileResource(path: String): Resource[IO, BufferedReader] =
-  Resource.make(
-    IO.blocking(new BufferedReader(new FileReader(path)))
-  )(reader => IO.blocking(reader.close()))
-
-def readLines(path: String): IO[List[String]] = {
-  fileResource(path).use { reader =>
-    IO.blocking {
-      Iterator
-        .continually(reader.readLine())
-        .takeWhile(_ != null)
-        .toList
-    }
-  }
-}
-
-// 使用例
-val program: IO[Unit] = for {
-  lines <- readLines("data.txt")
-  _     <- IO.println(s"Read ${lines.size} lines")
-} yield ()
-```
-
-</details>
-
----
-
-## シリーズ全体の総括
-
-本シリーズでは、「Grokking Functional Programming」の内容に沿って、関数型プログラミングの基礎から実践的なアプリケーション構築までを学びました。
-
-### 学んだ主な概念
-
-| Part | 章 | 主な概念 |
-|------|-----|----------|
-| I | 1-2 | 純粋関数、参照透過性 |
-| II | 3-5 | イミュータブルデータ、高階関数、flatMap |
-| III | 6-7 | Option、Either、ADT |
-| IV | 8-9 | IO モナド、Stream |
-| V | 10 | 並行処理、Ref、Fiber |
-| VI | 11-12 | 実践アプリケーション、テスト |
-
-### 関数型プログラミングの利点
-
-1. **予測可能性**: 純粋関数は同じ入力に対して常に同じ出力
-2. **テスト容易性**: 副作用がないためテストが簡単
-3. **合成可能性**: 小さな関数を組み合わせて複雑な処理を構築
-4. **並行安全性**: イミュータブルデータは競合状態を防ぐ
-5. **型安全性**: Option、Either で null や例外を型で表現
-
-### 次のステップ
-
-- Cats Effect のより高度な機能を学ぶ
-- fs2 の実践的な使用方法を深める
-- ZIO など他の FP ライブラリを探索
-- 実際のプロジェクトで FP を適用する
+# Part VI: 実践的なアプリケーション構築とテスト
+
+本章では、これまで学んだ関数型プログラミングの概念を統合し、実践的なアプリケーションを構築します。また、関数型プログラミングにおけるテスト戦略についても学びます。
+
+---
+
+## 第11章: 実践的なアプリケーション構築
+
+### 11.1 TravelGuide アプリケーション
+
+旅行ガイドアプリケーションを例に、実践的な FP アプリケーションの構築方法を学びます。
+
+```plantuml
+@startuml
+!theme plain
+
+package "TravelGuide Application" {
+  rectangle "Model" {
+    class Location {
+      id: LocationId
+      name: String
+      population: Int
+    }
+
+    class Attraction {
+      name: String
+      description: Option[String]
+      location: Location
+    }
+
+    class TravelGuide {
+      attraction: Attraction
+      subjects: List[String]
+    }
+  }
+
+  rectangle "Data Access" {
+    interface DataAccess {
+      +findAttractions(): IO[List[Attraction]]
+      +findArtistsFromLocation(): IO[List[MusicArtist]]
+      +findMoviesAboutLocation(): IO[List[Movie]]
+    }
+
+    class WikidataDataAccess
+    class CachedDataAccess
+  }
+
+  DataAccess <|.. WikidataDataAccess
+  DataAccess <|.. CachedDataAccess
+}
+
+@enduml
+```
+
+### 11.2 ドメインモデルの定義
+
+**ソースファイル**: `app/scala/src/main/scala/ch11_TravelGuide.scala`
+
+```scala
+// 位置情報を表す値オブジェクト
+opaque type LocationId = String
+object LocationId {
+  def apply(value: String): LocationId = value
+  extension (a: LocationId) def value: String = a
+}
+
+// ロケーション
+case class Location(id: LocationId, name: String, population: Int)
+
+// アトラクション（観光地）
+case class Attraction(
+    name: String,
+    description: Option[String],
+    location: Location
+)
+
+// 旅行ガイド
+case class TravelGuide(attraction: Attraction, subjects: List[String])
+```
+
+### 11.3 データアクセス層の抽象化
+
+外部データソースへのアクセスをトレイトで抽象化します。
+
+```scala
+trait DataAccess {
+  def findAttractions(
+      name: String,
+      ordering: AttractionOrdering,
+      limit: Int
+  ): IO[List[Attraction]]
+
+  def findArtistsFromLocation(
+      locationId: LocationId,
+      limit: Int
+  ): IO[List[MusicArtist]]
+
+  def findMoviesAboutLocation(
+      locationId: LocationId,
+      limit: Int
+  ): IO[List[Movie]]
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+interface DataAccess {
+  +findAttractions(): IO[List[Attraction]]
+  +findArtistsFromLocation(): IO[List[MusicArtist]]
+  +findMoviesAboutLocation(): IO[List[Movie]]
+}
+
+note right of DataAccess
+  純粋な関数型インターフェース
+  すべての操作は IO でラップ
+end note
+
+class WikidataDataAccess {
+  -sparqlEndpoint: String
+  +findAttractions(): IO[List[Attraction]]
+  +findArtistsFromLocation(): IO[List[MusicArtist]]
+  +findMoviesAboutLocation(): IO[List[Movie]]
+}
+
+class TestDataAccess {
+  -testData: Map[String, List[Attraction]]
+  +findAttractions(): IO[List[Attraction]]
+  +findArtistsFromLocation(): IO[List[MusicArtist]]
+  +findMoviesAboutLocation(): IO[List[Movie]]
+}
+
+DataAccess <|.. WikidataDataAccess
+DataAccess <|.. TestDataAccess
+
+@enduml
+```
+
+### 11.4 Resource によるリソース管理
+
+cats-effect の `Resource` を使用して、安全なリソース管理を実現します。
+
+**ソースファイル**: `app/scala/src/main/scala/ch11_TravelGuide.scala`
+
+```scala
+def execQuery(
+    query: String
+): Resource[IO, List[QuerySolution]] = {
+  val connection: Resource[IO, RDFConnection] =
+    Resource.make(
+      IO.blocking(
+        RDFConnectionRemote
+          .create()
+          .destination(WikidataSparqlEndpoint)
+          .build()
+      )
+    )(connection => IO.blocking(connection.close()))
+
+  for {
+    conn   <- connection
+    result <- Resource.eval(IO.blocking {
+      val resultSet = conn.query(query).execSelect()
+      resultSet.asScala.toList
+    })
+  } yield result
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+participant "Application" as app
+participant "Resource" as res
+participant "RDFConnection" as conn
+participant "SPARQL Endpoint" as sparql
+
+app -> res: Resource.make(acquire)(release)
+res -> conn: acquire: IO.blocking(create())
+conn -> sparql: connect
+sparql --> conn: connection
+
+app -> res: use (query execution)
+res -> conn: query.execSelect()
+conn -> sparql: SPARQL query
+sparql --> conn: results
+conn --> res: List[QuerySolution]
+res --> app: results
+
+app -> res: release (automatic)
+res -> conn: IO.blocking(close())
+conn -> sparql: disconnect
+
+note over res
+  Resource は例外が発生しても
+  必ず release を実行する
+end note
+
+@enduml
+```
+
+### 11.5 キャッシュの実装
+
+`Ref` を使用したスレッドセーフなキャッシュの実装:
+
+```scala
+def cachedAttractions(
+    dataAccess: DataAccess
+): IO[DataAccess] = {
+  for {
+    cache <- Ref.of[IO, Map[String, List[Attraction]]](Map.empty)
+  } yield new DataAccess {
+    def findAttractions(
+        name: String,
+        ordering: AttractionOrdering,
+        limit: Int
+    ): IO[List[Attraction]] = {
+      val key = s"$name-$ordering-$limit"
+      for {
+        cached <- cache.get.map(_.get(key))
+        result <- cached match {
+          case Some(attractions) => IO.pure(attractions)
+          case None =>
+            for {
+              attractions <- dataAccess.findAttractions(name, ordering, limit)
+              _           <- cache.update(_ + (key -> attractions))
+            } yield attractions
+        }
+      } yield result
+    }
+
+    // 他のメソッドも同様に実装...
+  }
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+skinparam activity {
+  BackgroundColor White
+  BorderColor Black
+}
+
+start
+
+:キャッシュキー生成;
+
+:cache.get でキャッシュ確認;
+
+if (キャッシュにデータあり?) then (yes)
+  :キャッシュからデータ返却;
+else (no)
+  :外部 API を呼び出し;
+  :結果をキャッシュに保存;
+  :結果を返却;
+endif
+
+stop
+
+note right
+  Ref を使用した
+  スレッドセーフなキャッシュ
+end note
+
+@enduml
+```
+
+### 11.6 アプリケーションの組み立て
+
+すべてのコンポーネントを組み合わせてアプリケーションを構築します。
+
+```scala
+def travelGuide(data: DataAccess, attractionName: String): IO[Option[TravelGuide]] = {
+  for {
+    attractions <- data.findAttractions(attractionName, ByLocationPopulation, 1)
+    guide <- attractions.headOption match {
+      case None => IO.pure(None)
+      case Some(attraction) =>
+        for {
+          artists <- data.findArtistsFromLocation(attraction.location.id, 2)
+          movies  <- data.findMoviesAboutLocation(attraction.location.id, 2)
+        } yield Some(
+          TravelGuide(
+            attraction,
+            artists.map(_.name) ++ movies.map(_.name)
+          )
+        )
+    }
+  } yield guide
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "travelGuide 関数" {
+  card "1. アトラクション検索" as step1
+  card "2. アーティスト検索" as step2
+  card "3. 映画検索" as step3
+  card "4. TravelGuide 組み立て" as step4
+
+  step1 --> step2 : attraction
+  step1 --> step3 : location.id
+  step2 --> step4 : artists
+  step3 --> step4 : movies
+}
+
+note bottom
+  for 内包表記で
+  複数の IO を合成
+end note
+
+@enduml
+```
+
+---
+
+## 第12章: テスト戦略
+
+### 12.1 関数型プログラミングのテスト
+
+関数型プログラミングでは、純粋関数のおかげでテストが非常に簡単になります。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "テストの種類" {
+  rectangle "単体テスト" as unit {
+    card "純粋関数のテスト"
+    card "高速・独立"
+  }
+
+  rectangle "プロパティベーステスト" as property {
+    card "ランダム入力"
+    card "不変条件の検証"
+  }
+
+  rectangle "統合テスト" as integration {
+    card "コンポーネント連携"
+    card "スタブ/モック使用"
+  }
+}
+
+unit --> property : 補完
+property --> integration : 補完
+
+@enduml
+```
+
+### 12.2 SearchReport の導入
+
+**ソースファイル**: `app/scala/src/main/scala/ch12_TravelGuide.scala`
+
+テスト可能性を高めるため、`SearchReport` を導入します。
+
+```scala
+case class SearchReport(
+    attractionsSearched: Int,
+    errors: List[String]
+)
+
+case class TravelGuide(
+    attraction: Attraction,
+    subjects: List[String],
+    searchReport: SearchReport
+)
+```
+
+```plantuml
+@startuml
+!theme plain
+
+class TravelGuide {
+  attraction: Attraction
+  subjects: List[String]
+  searchReport: SearchReport
+}
+
+class SearchReport {
+  attractionsSearched: Int
+  errors: List[String]
+}
+
+TravelGuide --> SearchReport
+
+note right of SearchReport
+  検索の統計情報と
+  エラー情報を保持
+end note
+
+@enduml
+```
+
+### 12.3 エラーハンドリングの改善
+
+```scala
+def findArtistsFromLocation(
+    locationId: LocationId,
+    limit: Int
+): IO[Either[String, List[MusicArtist]]]
+
+def findMoviesAboutLocation(
+    locationId: LocationId,
+    limit: Int
+): IO[Either[String, List[Movie]]]
+```
+
+Either を使用してエラーを明示的に扱います:
+
+```scala
+def travelGuide(
+    data: DataAccess,
+    attractionName: String
+): IO[Option[TravelGuide]] = {
+  for {
+    attractions <- data.findAttractions(attractionName, ByLocationPopulation, 3)
+    guides <- attractions.traverse { attraction =>
+      for {
+        artistsResult <- data.findArtistsFromLocation(attraction.location.id, 2)
+        moviesResult  <- data.findMoviesAboutLocation(attraction.location.id, 2)
+      } yield {
+        val errors = List(artistsResult, moviesResult).collect {
+          case Left(error) => error
+        }
+        val artists = artistsResult.getOrElse(Nil)
+        val movies = moviesResult.getOrElse(Nil)
+        TravelGuide(
+          attraction,
+          artists.map(_.name) ++ movies.map(_.name),
+          SearchReport(attractions.size, errors)
+        )
+      }
+    }
+  } yield guides.headOption
+}
+```
+
+### 12.4 スタブを使用したテスト
+
+**ソースファイル**: `app/scala/src/main/scala/ch12_TravelGuideTest.scala`
+
+```scala
+// テスト用のスタブ実装
+val testDataAccess: DataAccess = new DataAccess {
+  def findAttractions(
+      name: String,
+      ordering: AttractionOrdering,
+      limit: Int
+  ): IO[List[Attraction]] = IO.pure(
+    List(
+      Attraction(
+        "Test Attraction",
+        Some("A test attraction"),
+        Location(LocationId("Q123"), "Test City", 100000)
+      )
+    )
+  )
+
+  def findArtistsFromLocation(
+      locationId: LocationId,
+      limit: Int
+  ): IO[Either[String, List[MusicArtist]]] =
+    IO.pure(Right(List(MusicArtist("Test Artist"))))
+
+  def findMoviesAboutLocation(
+      locationId: LocationId,
+      limit: Int
+  ): IO[Either[String, List[Movie]]] =
+    IO.pure(Right(List(Movie("Test Movie"))))
+}
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "テスト構成" {
+  rectangle "本番" as prod {
+    interface "DataAccess" as da1
+    class "WikidataDataAccess" as wda
+    da1 <|.. wda
+  }
+
+  rectangle "テスト" as test {
+    interface "DataAccess" as da2
+    class "TestDataAccess" as tda
+    da2 <|.. tda
+  }
+}
+
+note bottom of prod
+  実際の Wikidata に接続
+end note
+
+note bottom of test
+  テストデータを返す
+  IO.pure で即座に結果を返す
+end note
+
+@enduml
+```
+
+### 12.5 プロパティベーステスト
+
+ScalaCheck を使用したプロパティベーステスト:
+
+```scala
+import org.scalacheck.Gen
+import org.scalacheck.Prop.forAll
+
+// ジェネレータの定義
+val locationIdGen: Gen[LocationId] =
+  Gen.alphaNumStr.map(LocationId.apply)
+
+val locationGen: Gen[Location] = for {
+  id         <- locationIdGen
+  name       <- Gen.alphaStr
+  population <- Gen.posNum[Int]
+} yield Location(id, name, population)
+
+val attractionGen: Gen[Attraction] = for {
+  name        <- Gen.alphaStr
+  description <- Gen.option(Gen.alphaStr)
+  location    <- locationGen
+} yield Attraction(name, description, location)
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "プロパティベーステスト" {
+  card "Gen[A]" as gen
+  card "ランダムデータ生成" as random
+  card "プロパティ検証" as verify
+  card "100回以上テスト" as repeat
+
+  gen --> random
+  random --> verify
+  verify --> repeat
+  repeat --> random : 繰り返し
+}
+
+note bottom
+  ランダムな入力で
+  不変条件を検証
+end note
+
+@enduml
+```
+
+### 12.6 不変条件のテスト
+
+```scala
+// プロパティ: アトラクションの数は limit 以下
+property("findAttractions returns at most limit attractions") =
+  forAll(Gen.alphaStr, Gen.posNum[Int]) { (name: String, limit: Int) =>
+    val result = dataAccess
+      .findAttractions(name, ByLocationPopulation, limit)
+      .unsafeRunSync()
+    result.size <= limit
+  }
+
+// プロパティ: SearchReport のエラー数は検索数以下
+property("SearchReport errors are bounded by searches") =
+  forAll(attractionGen) { attraction =>
+    val guide = travelGuide(testDataAccess, attraction.name).unsafeRunSync()
+    guide.forall { g =>
+      g.searchReport.errors.size <= 2 // artists + movies
+    }
+  }
+```
+
+### 12.7 統合テスト
+
+```scala
+// 統合テスト: エンドツーエンドのシナリオ
+test("travelGuide returns guide for valid attraction") {
+  val result = travelGuide(testDataAccess, "Test").unsafeRunSync()
+
+  assert(result.isDefined)
+  result.foreach { guide =>
+    assert(guide.attraction.name == "Test Attraction")
+    assert(guide.subjects.nonEmpty)
+    assert(guide.searchReport.errors.isEmpty)
+  }
+}
+
+// エラーケースのテスト
+test("travelGuide handles errors gracefully") {
+  val failingDataAccess = new DataAccess {
+    def findAttractions(name: String, ordering: AttractionOrdering, limit: Int) =
+      IO.pure(List(testAttraction))
+
+    def findArtistsFromLocation(locationId: LocationId, limit: Int) =
+      IO.pure(Left("Network error"))
+
+    def findMoviesAboutLocation(locationId: LocationId, limit: Int) =
+      IO.pure(Left("Timeout"))
+  }
+
+  val result = travelGuide(failingDataAccess, "Test").unsafeRunSync()
+
+  assert(result.isDefined)
+  result.foreach { guide =>
+    assert(guide.searchReport.errors.size == 2)
+  }
+}
+```
+
+### 12.8 テストピラミッド
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "テストピラミッド" {
+  rectangle "E2E テスト\n(少数)" as e2e
+  rectangle "統合テスト\n(中程度)" as integration
+  rectangle "単体テスト + プロパティテスト\n(多数)" as unit
+}
+
+e2e -[hidden]down- integration
+integration -[hidden]down- unit
+
+note right of unit
+  FP では純粋関数が多いため
+  単体テストが非常に効果的
+end note
+
+@enduml
+```
+
+---
+
+## まとめ
+
+### Part VI で学んだこと
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Part VI: 実践的なアプリケーション" {
+  rectangle "第11章" as ch11 {
+    card "ドメインモデル設計"
+    card "DataAccess 抽象化"
+    card "Resource 管理"
+    card "キャッシュ実装"
+  }
+
+  rectangle "第12章" as ch12 {
+    card "SearchReport"
+    card "スタブ/モック"
+    card "プロパティベーステスト"
+    card "統合テスト"
+  }
+}
+
+ch11 --> ch12
+
+@enduml
+```
+
+### キーポイント
+
+1. **抽象化の重要性**: DataAccess トレイトで外部依存を抽象化
+2. **Resource でリソース管理**: 安全なリソースの取得と解放
+3. **Ref でキャッシュ**: スレッドセーフな状態管理
+4. **Either でエラー処理**: 明示的なエラーハンドリング
+5. **SearchReport**: テスト可能性と可観測性の向上
+6. **スタブ**: 外部依存を差し替えてテスト
+7. **プロパティベーステスト**: ランダム入力で不変条件を検証
+
+### 学習の総括
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "FP の学習パス" {
+  card "Part I\n基礎" as p1
+  card "Part II\nイミュータブル操作" as p2
+  card "Part III\n型による安全性" as p3
+  card "Part IV\nIO/Stream" as p4
+  card "Part V\n並行処理" as p5
+  card "Part VI\n実践" as p6
+}
+
+p1 --> p2
+p2 --> p3
+p3 --> p4
+p4 --> p5
+p5 --> p6
+
+@enduml
+```
+
+---
+
+## 演習問題
+
+### 問題 1: DataAccess の拡張
+
+以下の要件で `DataAccess` を拡張してください:
+
+
+- 新しいメソッド `findHotelsNearLocation` を追加
+- 戻り値は `IO[Either[String, List[Hotel]]]`
+
+<details>
+<summary>解答</summary>
+
+```scala
+case class Hotel(name: String, rating: Double, location: Location)
+
+trait DataAccess {
+  // 既存のメソッド...
+
+  def findHotelsNearLocation(
+      locationId: LocationId,
+      limit: Int
+  ): IO[Either[String, List[Hotel]]]
+}
+
+// テスト用スタブ
+val testDataAccess: DataAccess = new DataAccess {
+  // 既存の実装...
+
+  def findHotelsNearLocation(
+      locationId: LocationId,
+      limit: Int
+  ): IO[Either[String, List[Hotel]]] =
+    IO.pure(Right(List(
+      Hotel("Test Hotel", 4.5, testLocation)
+    )))
+}
+```
+
+</details>
+
+### 問題 2: プロパティベーステスト
+
+以下の関数に対するプロパティベーステストを書いてください:
+
+```scala
+def filterPopularLocations(
+    locations: List[Location],
+    minPopulation: Int
+): List[Location] =
+  locations.filter(_.population >= minPopulation)
+```
+
+<details>
+<summary>解答</summary>
+
+```scala
+import org.scalacheck.Gen
+import org.scalacheck.Prop.forAll
+
+val locationGen: Gen[Location] = for {
+  id         <- Gen.alphaNumStr.map(LocationId.apply)
+  name       <- Gen.alphaStr
+  population <- Gen.chooseNum(0, 10000000)
+} yield Location(id, name, population)
+
+val locationsGen: Gen[List[Location]] =
+  Gen.listOf(locationGen)
+
+// プロパティ1: 結果は入力以下の要素数
+property("result size <= input size") =
+  forAll(locationsGen, Gen.posNum[Int]) {
+    (locations: List[Location], minPop: Int) =>
+      filterPopularLocations(locations, minPop).size <= locations.size
+  }
+
+// プロパティ2: 結果のすべての要素は条件を満たす
+property("all results meet minimum population") =
+  forAll(locationsGen, Gen.posNum[Int]) {
+    (locations: List[Location], minPop: Int) =>
+      filterPopularLocations(locations, minPop)
+        .forall(_.population >= minPop)
+  }
+
+// プロパティ3: 条件を満たす要素はすべて結果に含まれる
+property("all qualifying locations are in result") =
+  forAll(locationsGen, Gen.posNum[Int]) {
+    (locations: List[Location], minPop: Int) =>
+      val result = filterPopularLocations(locations, minPop)
+      locations.filter(_.population >= minPop).forall(result.contains)
+  }
+```
+
+</details>
+
+### 問題 3: Resource の実装
+
+ファイルを安全に読み取る `Resource` を実装してください。
+
+<details>
+<summary>解答</summary>
+
+```scala
+import cats.effect.{IO, Resource}
+import java.io.{BufferedReader, FileReader}
+
+def fileResource(path: String): Resource[IO, BufferedReader] =
+  Resource.make(
+    IO.blocking(new BufferedReader(new FileReader(path)))
+  )(reader => IO.blocking(reader.close()))
+
+def readLines(path: String): IO[List[String]] = {
+  fileResource(path).use { reader =>
+    IO.blocking {
+      Iterator
+        .continually(reader.readLine())
+        .takeWhile(_ != null)
+        .toList
+    }
+  }
+}
+
+// 使用例
+val program: IO[Unit] = for {
+  lines <- readLines("data.txt")
+  _     <- IO.println(s"Read ${lines.size} lines")
+} yield ()
+```
+
+</details>
+
+---
+
+## シリーズ全体の総括
+
+本シリーズでは、「Grokking Functional Programming」の内容に沿って、関数型プログラミングの基礎から実践的なアプリケーション構築までを学びました。
+
+### 学んだ主な概念
+
+| Part | 章 | 主な概念 |
+|------|-----|----------|
+| I | 1-2 | 純粋関数、参照透過性 |
+| II | 3-5 | イミュータブルデータ、高階関数、flatMap |
+| III | 6-7 | Option、Either、ADT |
+| IV | 8-9 | IO モナド、Stream |
+| V | 10 | 並行処理、Ref、Fiber |
+| VI | 11-12 | 実践アプリケーション、テスト |
+
+### 関数型プログラミングの利点
+
+1. **予測可能性**: 純粋関数は同じ入力に対して常に同じ出力
+2. **テスト容易性**: 副作用がないためテストが簡単
+3. **合成可能性**: 小さな関数を組み合わせて複雑な処理を構築
+4. **並行安全性**: イミュータブルデータは競合状態を防ぐ
+5. **型安全性**: Option、Either で null や例外を型で表現
+
+### 次のステップ
+
+- Cats Effect のより高度な機能を学ぶ
+- fs2 の実践的な使用方法を深める
+- ZIO など他の FP ライブラリを探索
+- 実際のプロジェクトで FP を適用する