@k2works/claude-code-booster 4.8.0 → 4.11.0

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

@@ -1,1049 +1,1049 @@
-# Part VI: 実践的なアプリケーション構築とテスト
-
-本章では、これまで学んだ関数型プログラミングの概念を統合し、実践的なアプリケーションを構築します。また、関数型プログラミングにおけるテスト戦略についても学びます。
-
----
-
-## 第12章: 実践的なアプリケーションとテスト戦略
-
-### 12.1 TravelGuide アプリケーション
-
-旅行ガイドアプリケーションを例に、実践的な FP アプリケーションの構築方法を学びます。
-
-```plantuml
-@startuml
-!theme plain
-
-package "TravelGuide Application" {
-  rectangle "Model" {
-    class Location {
-      id: LocationId
-      name: String
-      population: integer
-    }
-
-    class Attraction {
-      name: String
-      description: String | nil
-      location: Location
-    }
-
-    class TravelGuide {
-      attraction: Attraction
-      subjects: [String]
-      search_report: SearchReport
-    }
-  }
-
-  rectangle "Data Access" {
-    interface DataAccess {
-      +find_attractions(): {:ok, [Attraction]} | {:error, String}
-      +find_artists_from_location(): {:ok, [MusicArtist]} | {:error, String}
-      +find_movies_about_location(): {:ok, [Movie]} | {:error, String}
-    }
-
-    class TestDataAccess
-    class CachedDataAccess
-  }
-
-  DataAccess <|.. TestDataAccess
-  DataAccess <|.. CachedDataAccess
-}
-
-@enduml
-```
-
-### 12.2 ドメインモデルの定義
-
-**ソースファイル**: `app/elixir/lib/ch12/travel_guide.ex`
-
-Elixir では構造体（struct）を使ってドメインモデルを定義します。
-
-```elixir
-defmodule LocationId do
-  @moduledoc "位置情報 ID（Value Object）"
-  defstruct [:value]
-
-  @type t :: %__MODULE__{value: String.t()}
-
-  @spec new(String.t()) :: t()
-  def new(value), do: %__MODULE__{value: value}
-end
-
-defmodule Location do
-  @moduledoc "ロケーション"
-  defstruct [:id, :name, :population]
-
-  @type t :: %__MODULE__{
-          id: LocationId.t(),
-          name: String.t(),
-          population: non_neg_integer()
-        }
-
-  @spec new(LocationId.t(), String.t(), non_neg_integer()) :: t()
-  def new(id, name, population) do
-    %__MODULE__{id: id, name: name, population: population}
-  end
-end
-
-defmodule Attraction do
-  @moduledoc "アトラクション（観光地）"
-  defstruct [:name, :description, :location]
-
-  @type t :: %__MODULE__{
-          name: String.t(),
-          description: String.t() | nil,
-          location: Location.t()
-        }
-
-  @spec new(String.t(), String.t() | nil, Location.t()) :: t()
-  def new(name, description, location) do
-    %__MODULE__{name: name, description: description, location: location}
-  end
-end
-```
-
-### 12.3 データアクセス層の抽象化
-
-Elixir では `@behaviour` を使用してインターフェースを定義します。
-
-```elixir
-defmodule DataAccess do
-  @moduledoc """
-  データアクセス層のインターフェース（振る舞い）
-
-  実装モジュールはこの振る舞いを実装する必要がある。
-  """
-
-  @type ordering :: :by_name | :by_location_population
-
-  @callback find_attractions(String.t(), ordering(), pos_integer()) ::
-              {:ok, [Attraction.t()]} | {:error, String.t()}
-
-  @callback find_artists_from_location(LocationId.t(), pos_integer()) ::
-              {:ok, [MusicArtist.t()]} | {:error, String.t()}
-
-  @callback find_movies_about_location(LocationId.t(), pos_integer()) ::
-              {:ok, [Movie.t()]} | {:error, String.t()}
-
-  @callback find_hotels_near_location(LocationId.t(), pos_integer()) ::
-              {:ok, [Hotel.t()]} | {:error, String.t()}
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-
-interface DataAccess {
-  +find_attractions(): {:ok, [Attraction]} | {:error, String}
-  +find_artists_from_location(): {:ok, [MusicArtist]} | {:error, String}
-  +find_movies_about_location(): {:ok, [Movie]} | {:error, String}
-}
-
-note right of DataAccess
-  @behaviour による振る舞い定義
-  実装モジュールは @impl true で実装
-end note
-
-class TestDataAccess {
-  +find_attractions(): {:ok, [Attraction]}
-  +find_artists_from_location(): {:ok, [MusicArtist]}
-  +find_movies_about_location(): {:ok, [Movie]}
-}
-
-class FailingDataAccess {
-  +find_attractions(): {:ok, [Attraction]}
-  +find_artists_from_location(): {:error, String}
-  +find_movies_about_location(): {:error, String}
-}
-
-DataAccess <|.. TestDataAccess
-DataAccess <|.. FailingDataAccess
-
-@enduml
-```
-
-### 12.4 スタブ実装
-
-テスト用のスタブ実装を作成します。
-
-```elixir
-defmodule TestDataAccess do
-  @moduledoc "テスト用のスタブ実装"
-  @behaviour DataAccess
-
-  @impl true
-  def find_attractions(name, _ordering, limit) do
-    attractions =
-      case name do
-        "Empty" -> []
-        _ ->
-          [
-            Attraction.new("#{name} Tower", "A famous tower", @test_location),
-            Attraction.new("#{name} Park", "A beautiful park", @test_location),
-            Attraction.new("#{name} Museum", "A great museum", @test_location)
-          ]
-      end
-
-    {:ok, Enum.take(attractions, limit)}
-  end
-
-  @impl true
-  def find_artists_from_location(_location_id, limit) do
-    artists = [
-      MusicArtist.new("Test Artist 1", "Pop"),
-      MusicArtist.new("Test Artist 2", "Rock")
-    ]
-
-    {:ok, Enum.take(artists, limit)}
-  end
-
-  # 他のコールバックも同様に実装...
-end
-```
-
-### 12.5 Agent を使用したキャッシュ
-
-Elixir の Agent を使用して、スレッドセーフなキャッシュを実装します。
-
-```elixir
-defmodule CachedDataAccess do
-  @moduledoc """
-  Agent を使ったキャッシュ付きデータアクセス
-  """
-
-  @spec start_link(module()) :: {:ok, pid()}
-  def start_link(data_access_module) do
-    Agent.start_link(fn ->
-      %{
-        module: data_access_module,
-        attractions_cache: %{},
-        artists_cache: %{},
-        movies_cache: %{},
-        hotels_cache: %{}
-      }
-    end)
-  end
-
-  @spec find_attractions(pid(), String.t(), DataAccess.ordering(), pos_integer()) ::
-          {:ok, [Attraction.t()]} | {:error, String.t()}
-  def find_attractions(cache, name, ordering, limit) do
-    key = "#{name}-#{ordering}-#{limit}"
-
-    Agent.get_and_update(cache, fn state ->
-      case Map.get(state.attractions_cache, key) do
-        nil ->
-          result = state.module.find_attractions(name, ordering, limit)
-
-          case result do
-            {:ok, attractions} ->
-              new_cache = Map.put(state.attractions_cache, key, attractions)
-              {result, %{state | attractions_cache: new_cache}}
-
-            {:error, _} = error ->
-              {error, state}
-          end
-
-        cached ->
-          {{:ok, cached}, state}
-      end
-    end)
-  end
-
-  # 他のメソッドも同様に実装...
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-skinparam activity {
-  BackgroundColor White
-  BorderColor Black
-}
-
-start
-
-:キャッシュキー生成;
-
-:Agent.get_and_update でキャッシュ確認;
-
-if (キャッシュにデータあり?) then (yes)
-  :キャッシュからデータ返却;
-else (no)
-  :外部モジュールを呼び出し;
-  :結果をキャッシュに保存;
-  :結果を返却;
-endif
-
-stop
-
-note right
-  Agent を使用した
-  スレッドセーフなキャッシュ
-end note
-
-@enduml
-```
-
-### 12.6 アプリケーションの組み立て
-
-すべてのコンポーネントを組み合わせてアプリケーションを構築します。
-
-```elixir
-@spec travel_guide(module(), String.t()) :: {:ok, TravelGuide.t()} | {:error, String.t()}
-def travel_guide(data_access_module, attraction_name) do
-  case data_access_module.find_attractions(attraction_name, :by_location_population, 1) do
-    {:ok, []} ->
-      {:error, "No attractions found"}
-
-    {:ok, [attraction | _]} ->
-      build_guide(data_access_module, attraction, 1)
-
-    {:error, reason} ->
-      {:error, reason}
-  end
-end
-
-defp build_guide(data_access_module, attraction, attractions_searched) do
-  location_id = attraction.location.id
-
-  artists_result = data_access_module.find_artists_from_location(location_id, 2)
-  movies_result = data_access_module.find_movies_about_location(location_id, 2)
-
-  errors =
-    [artists_result, movies_result]
-    |> Enum.filter(&match?({:error, _}, &1))
-    |> Enum.map(fn {:error, reason} -> reason end)
-
-  artists =
-    case artists_result do
-      {:ok, list} -> list
-      {:error, _} -> []
-    end
-
-  movies =
-    case movies_result do
-      {:ok, list} -> list
-      {:error, _} -> []
-    end
-
-  subjects = Enum.map(artists, & &1.name) ++ Enum.map(movies, & &1.name)
-  report = SearchReport.new(attractions_searched, errors)
-
-  {:ok, TravelGuide.new(attraction, subjects, report)}
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "travel_guide 関数" {
-  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
-  パターンマッチングで
-  複数の結果を合成
-end note
-
-@enduml
-```
-
-### 12.7 SearchReport の導入
-
-テスト可能性を高めるため、`SearchReport` を導入します。
-
-**ソースファイル**: `app/elixir/lib/ch12/travel_guide.ex`
-
-```elixir
-defmodule SearchReport do
-  @moduledoc "検索レポート"
-  defstruct [:attractions_searched, :errors]
-
-  @type t :: %__MODULE__{
-          attractions_searched: non_neg_integer(),
-          errors: [String.t()]
-        }
-
-  @spec new(non_neg_integer(), [String.t()]) :: t()
-  def new(attractions_searched, errors \\ []) do
-    %__MODULE__{attractions_searched: attractions_searched, errors: errors}
-  end
-
-  @spec empty() :: t()
-  def empty, do: new(0, [])
-
-  @spec add_error(t(), String.t()) :: t()
-  def add_error(%__MODULE__{} = report, error) do
-    %{report | errors: report.errors ++ [error]}
-  end
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-
-class TravelGuide {
-  attraction: Attraction
-  subjects: [String]
-  search_report: SearchReport
-}
-
-class SearchReport {
-  attractions_searched: integer
-  errors: [String]
-}
-
-TravelGuide --> SearchReport
-
-note right of SearchReport
-  検索の統計情報と
-  エラー情報を保持
-end note
-
-@enduml
-```
-
----
-
-## テスト戦略
-
-### 12.8 関数型プログラミングのテスト
-
-関数型プログラミングでは、純粋関数のおかげでテストが非常に簡単になります。
-
-```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.9 純粋関数のテスト
-
-**ソースファイル**: `app/elixir/lib/ch12/testing.ex`
-
-純粋関数は入力と出力だけを考えればよいため、テストが簡単です。
-
-```elixir
-# テスト対象の純粋関数
-@spec filter_popular_locations([Location.t()], non_neg_integer()) :: [Location.t()]
-def filter_popular_locations(locations, min_population) do
-  Enum.filter(locations, fn loc -> loc.population >= min_population end)
-end
-
-@spec sort_by_population([Attraction.t()]) :: [Attraction.t()]
-def sort_by_population(attractions) do
-  Enum.sort_by(attractions, fn a -> a.location.population end, :desc)
-end
-
-@spec aggregate_results([{:ok, any()} | {:error, String.t()}]) ::
-        {[any()], [String.t()]}
-def aggregate_results(results) do
-  Enum.reduce(results, {[], []}, fn result, {successes, errors} ->
-    case result do
-      {:ok, value} -> {successes ++ [value], errors}
-      {:error, reason} -> {successes, errors ++ [reason]}
-    end
-  end)
-end
-```
-
-### 12.10 プロパティベーステスト
-
-**ソースファイル**: `app/elixir/lib/ch12/testing.ex`
-
-ランダムな入力を生成して不変条件をテストします。
-
-```elixir
-@doc """
-プロパティをテスト（指定回数実行）
-"""
-@spec check_property(pos_integer(), (-> boolean())) :: :ok | {:error, String.t()}
-def check_property(iterations, property_fn) do
-  results =
-    Enum.map(1..iterations, fn _ ->
-      try do
-        property_fn.()
-      rescue
-        _ -> false
-      end
-    end)
-
-  if Enum.all?(results) do
-    :ok
-  else
-    failed_count = Enum.count(results, &(!&1))
-    {:error, "Property failed #{failed_count}/#{iterations} times"}
-  end
-end
-
-@doc """
-filter_popular_locations の不変条件をテスト
-"""
-@spec verify_filter_properties(pos_integer()) :: :ok | {:error, String.t()}
-def verify_filter_properties(iterations) do
-  check_property(iterations, fn ->
-    locations = random_locations(:rand.uniform(20))
-    min_population = random_positive_int(5_000_000)
-
-    result = TravelGuide.filter_popular_locations(locations, min_population)
-
-    # プロパティ1: 結果のサイズは入力以下
-    size_property = length(result) <= length(locations)
-
-    # プロパティ2: 結果のすべての要素は条件を満たす
-    all_meet_condition = Enum.all?(result, fn loc -> loc.population >= min_population end)
-
-    # プロパティ3: 条件を満たす要素はすべて結果に含まれる
-    qualifying = Enum.filter(locations, fn loc -> loc.population >= min_population end)
-    all_included = Enum.all?(qualifying, fn loc -> loc in result end)
-
-    size_property and all_meet_condition and all_included
-  end)
-end
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "プロパティベーステスト" {
-  card "random_location/0" as gen
-  card "ランダムデータ生成" as random
-  card "プロパティ検証" as verify
-  card "N回繰り返しテスト" as repeat
-
-  gen --> random
-  random --> verify
-  verify --> repeat
-  repeat --> random : 繰り返し
-}
-
-note bottom
-  ランダムな入力で
-  不変条件を検証
-end note
-
-@enduml
-```
-
-### 12.11 ランダムデータ生成
-
-```elixir
-@doc """
-ランダムな文字列を生成
-"""
-@spec random_string(pos_integer()) :: String.t()
-def random_string(length) do
-  :crypto.strong_rand_bytes(length)
-  |> Base.encode64()
-  |> binary_part(0, length)
-end
-
-@doc """
-ランダムな Location を生成
-"""
-@spec random_location() :: Location.t()
-def random_location do
-  id = LocationId.new("Q#{random_positive_int(1_000_000)}")
-  name = random_string(8)
-  population = random_positive_int(10_000_000)
-  Location.new(id, name, population)
-end
-
-@doc """
-ランダムな Attraction を生成
-"""
-@spec random_attraction() :: Attraction.t()
-def random_attraction do
-  name = random_string(10)
-  description = if :rand.uniform(2) == 1, do: random_string(20), else: nil
-  location = random_location()
-  Attraction.new(name, description, location)
-end
-```
-
-### 12.12 統合テスト
-
-```elixir
-@doc """
-TravelGuide の統合テストを実行
-"""
-@spec run_integration_tests() :: {:ok, map()}
-def run_integration_tests do
-  tests = [
-    {:normal_case, fn ->
-      case TravelGuide.travel_guide(TravelGuide.TestDataAccess, "Tokyo") do
-        {:ok, guide} ->
-          guide.attraction.name == "Tokyo Tower" and
-            length(guide.subjects) > 0 and
-            guide.search_report.errors == []
-
-        _ ->
-          false
-      end
-    end},
-    {:empty_result, fn ->
-      case TravelGuide.travel_guide(TravelGuide.TestDataAccess, "Empty") do
-        {:error, "No attractions found"} -> true
-        _ -> false
-      end
-    end},
-    {:error_handling, fn ->
-      case TravelGuide.travel_guide(TravelGuide.FailingDataAccess, "Test") do
-        {:ok, guide} ->
-          length(guide.search_report.errors) == 2
-
-        _ ->
-          false
-      end
-    end},
-    {:cached_access, fn ->
-      {:ok, cache} = TravelGuide.CachedDataAccess.start_link(TravelGuide.TestDataAccess)
-
-      result1 = TravelGuide.travel_guide_cached(cache, "Tokyo")
-      result2 = TravelGuide.travel_guide_cached(cache, "Tokyo")
-
-      stats = TravelGuide.CachedDataAccess.cache_stats(cache)
-      Agent.stop(cache)
-
-      case {result1, result2} do
-        {{:ok, g1}, {:ok, g2}} ->
-          g1.attraction.name == g2.attraction.name and
-            stats.attractions > 0
-
-        _ ->
-          false
-      end
-    end}
-  ]
-
-  results =
-    Enum.map(tests, fn {name, test_fn} ->
-      result =
-        try do
-          test_fn.()
-        rescue
-          _ -> false
-        end
-
-      {name, result}
-    end)
-
-  passed = Enum.count(results, fn {_, r} -> r end)
-  failed = Enum.count(results, fn {_, r} -> !r end)
-
-  {:ok, %{passed: passed, failed: failed, results: results}}
-end
-```
-
-```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
-    class "FailingDataAccess" as fda
-    da2 <|.. tda
-    da2 <|.. fda
-  }
-}
-
-note bottom of prod
-  実際の外部 API に接続
-end note
-
-note bottom of test
-  テストデータを返す
-  即座に結果を返す
-end note
-
-@enduml
-```
-
-### 12.13 パフォーマンステスト
-
-```elixir
-@doc """
-関数の実行時間を計測
-"""
-@spec measure_time((-> any())) :: {non_neg_integer(), any()}
-def measure_time(fun) do
-  {time, result} = :timer.tc(fun)
-  {time, result}
-end
-
-@doc """
-キャッシュの効果を測定
-"""
-@spec measure_cache_effect(pos_integer()) :: {:ok, map()}
-def measure_cache_effect(iterations) do
-  # キャッシュなしの時間
-  {uncached_time, _} =
-    measure_time(fn ->
-      Enum.each(1..iterations, fn _ ->
-        TravelGuide.travel_guide(TravelGuide.TestDataAccess, "Tokyo")
-      end)
-    end)
-
-  # キャッシュありの時間
-  {:ok, cache} = TravelGuide.CachedDataAccess.start_link(TravelGuide.TestDataAccess)
-
-  {cached_time, _} =
-    measure_time(fn ->
-      Enum.each(1..iterations, fn _ ->
-        TravelGuide.travel_guide_cached(cache, "Tokyo")
-      end)
-    end)
-
-  Agent.stop(cache)
-
-  {:ok,
-   %{
-     uncached_time: uncached_time,
-     cached_time: cached_time,
-     speedup: uncached_time / max(cached_time, 1)
-   }}
-end
-```
-
-### 12.14 テストピラミッド
-
-```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 "ドメインモデル" as model {
-    card "構造体による型定義"
-    card "Value Object パターン"
-  }
-
-  rectangle "データアクセス" as data {
-    card "@behaviour による抽象化"
-    card "スタブ実装"
-    card "Agent によるキャッシュ"
-  }
-
-  rectangle "テスト戦略" as test {
-    card "純粋関数のテスト"
-    card "プロパティベーステスト"
-    card "統合テスト"
-  }
-}
-
-model --> data
-data --> test
-
-@enduml
-```
-
-### キーポイント
-
-1. **@behaviour による抽象化**: DataAccess 振る舞いで外部依存を抽象化
-2. **Agent でキャッシュ**: スレッドセーフな状態管理
-3. **タプルでエラー処理**: `{:ok, value}` / `{:error, reason}` で明示的なエラーハンドリング
-4. **SearchReport**: テスト可能性と可観測性の向上
-5. **スタブ**: 外部依存を差し替えてテスト
-6. **プロパティベーステスト**: ランダム入力で不変条件を検証
-
-### Scala との対比
-
-| 概念 | Scala | Elixir |
-|------|-------|--------|
-| インターフェース | `trait` | `@behaviour` |
-| 状態管理 | `Ref[IO, A]` | `Agent` |
-| リソース管理 | `Resource[IO, A]` | プロセス / `with` |
-| エラー処理 | `Either[E, A]` | `{:ok, a} \| {:error, e}` |
-| 非同期処理 | `IO[A]` | `Task` / `GenServer` |
-| キャッシュ | `Ref` + `Map` | `Agent` + `Map` |
-
-### 学習の総括
-
-```plantuml
-@startuml
-!theme plain
-left to right direction
-
-rectangle "Elixir FP の学習パス" {
-  card "Part I\n基礎" as p1
-  card "Part II\nイミュータブル操作" as p2
-  card "Part III\n型とパターン" as p3
-  card "Part IV\nStream と再帰" as p4
-  card "Part V\n並行処理・OTP" as p5
-  card "Part VI\n実践" as p6
-}
-
-p1 --> p2
-p2 --> p3
-p3 --> p4
-p4 --> p5
-p5 --> p6
-
-@enduml
-```
-
----
-
-## 演習問題
-
-### 問題 1: DataAccess の拡張
-
-以下の要件で `DataAccess` を拡張してください:
-
-
-- 新しいコールバック `find_restaurants_near_location` を追加
-- 戻り値は `{:ok, [Restaurant.t()]} | {:error, String.t()}`
-
-<details>
-<summary>解答</summary>
-
-```elixir
-defmodule Restaurant do
-  defstruct [:name, :cuisine, :rating, :location]
-
-  @type t :: %__MODULE__{
-          name: String.t(),
-          cuisine: String.t(),
-          rating: float(),
-          location: Location.t()
-        }
-
-  @spec new(String.t(), String.t(), float(), Location.t()) :: t()
-  def new(name, cuisine, rating, location) do
-    %__MODULE__{name: name, cuisine: cuisine, rating: rating, location: location}
-  end
-end
-
-# DataAccess に追加
-@callback find_restaurants_near_location(LocationId.t(), pos_integer()) ::
-            {:ok, [Restaurant.t()]} | {:error, String.t()}
-
-# TestDataAccess の実装
-@impl true
-def find_restaurants_near_location(_location_id, limit) do
-  restaurants = [
-    Restaurant.new("Test Restaurant 1", "Japanese", 4.5, @test_location),
-    Restaurant.new("Test Restaurant 2", "Italian", 4.0, @test_location)
-  ]
-
-  {:ok, Enum.take(restaurants, limit)}
-end
-```
-
-</details>
-
-### 問題 2: プロパティベーステスト
-
-以下の関数に対するプロパティベーステストを書いてください:
-
-```elixir
-def merge_subjects(artists, movies) do
-  Enum.map(artists, & &1.name) ++ Enum.map(movies, & &1.name)
-end
-```
-
-<details>
-<summary>解答</summary>
-
-```elixir
-@spec verify_merge_properties(pos_integer()) :: :ok | {:error, String.t()}
-def verify_merge_properties(iterations) do
-  check_property(iterations, fn ->
-    artist_count = :rand.uniform(10)
-    movie_count = :rand.uniform(10)
-
-    artists = Enum.map(1..artist_count, fn i ->
-      MusicArtist.new("Artist #{i}", nil)
-    end)
-
-    movies = Enum.map(1..movie_count, fn i ->
-      Movie.new("Movie #{i}", nil)
-    end)
-
-    result = TravelGuide.merge_subjects(artists, movies)
-
-    # プロパティ1: 結果の長さは入力の合計
-    length_property = length(result) == artist_count + movie_count
-
-    # プロパティ2: すべてのアーティスト名が含まれる
-    artist_names = Enum.map(artists, & &1.name)
-    artists_included = Enum.all?(artist_names, fn n -> n in result end)
-
-    # プロパティ3: すべての映画名が含まれる
-    movie_names = Enum.map(movies, & &1.name)
-    movies_included = Enum.all?(movie_names, fn n -> n in result end)
-
-    length_property and artists_included and movies_included
-  end)
-end
-```
-
-</details>
-
-### 問題 3: キャッシュの有効期限
-
-`CachedDataAccess` にキャッシュの有効期限機能を追加してください。
-
-<details>
-<summary>解答</summary>
-
-```elixir
-defmodule CachedDataAccessWithTTL do
-  @moduledoc """
-  TTL（有効期限）付きキャッシュ
-  """
-
-  @default_ttl_ms 60_000  # 60秒
-
-  @spec start_link(module(), pos_integer()) :: {:ok, pid()}
-  def start_link(data_access_module, ttl_ms \\ @default_ttl_ms) do
-    Agent.start_link(fn ->
-      %{
-        module: data_access_module,
-        ttl_ms: ttl_ms,
-        attractions_cache: %{}  # key => {value, timestamp}
-      }
-    end)
-  end
-
-  @spec find_attractions(pid(), String.t(), DataAccess.ordering(), pos_integer()) ::
-          {:ok, [Attraction.t()]} | {:error, String.t()}
-  def find_attractions(cache, name, ordering, limit) do
-    key = "#{name}-#{ordering}-#{limit}"
-    now = System.monotonic_time(:millisecond)
-
-    Agent.get_and_update(cache, fn state ->
-      case Map.get(state.attractions_cache, key) do
-        {cached, timestamp} when now - timestamp < state.ttl_ms ->
-          # キャッシュが有効
-          {{:ok, cached}, state}
-
-        _ ->
-          # キャッシュが無効または存在しない
-          result = state.module.find_attractions(name, ordering, limit)
-
-          case result do
-            {:ok, attractions} ->
-              new_cache = Map.put(state.attractions_cache, key, {attractions, now})
-              {result, %{state | attractions_cache: new_cache}}
-
-            {:error, _} = error ->
-              {error, state}
-          end
-      end
-    end)
-  end
-end
-```
-
-</details>
-
----
-
-## シリーズ全体の総括
-
-本シリーズでは、「Grokking Functional Programming」の内容に沿って、Elixir による関数型プログラミングの基礎から実践的なアプリケーション構築までを学びました。
-
-### 学んだ主な概念
-
-| Part | 章 | 主な概念 |
-|------|-----|----------|
-| I | 1-2 | 純粋関数、イミュータビリティ |
-| II | 3-5 | パイプ演算子、高階関数、Enum |
-| III | 6-7 | パターンマッチング、with 式 |
-| IV | 8-9 | Stream、再帰 |
-| V | 10-11 | 並行処理、OTP パターン |
-| VI | 12 | 実践アプリケーション、テスト |
-
-### 関数型プログラミングの利点
-
-1. **予測可能性**: 純粋関数は同じ入力に対して常に同じ出力
-2. **テスト容易性**: 副作用がないためテストが簡単
-3. **合成可能性**: パイプ演算子で小さな関数を組み合わせ
-4. **並行安全性**: イミュータブルデータは競合状態を防ぐ
-5. **パターンマッチング**: 明確で安全なデータ処理
-
-### Elixir 特有の利点
-
-1. **OTP**: 堅牢な並行処理フレームワーク
-2. **BEAM VM**: 軽量プロセスと高いスケーラビリティ
-3. **パイプ演算子**: 読みやすいデータ変換
-4. **パターンマッチング**: 強力な分岐とデストラクチャリング
-5. **ホットコードスワップ**: 無停止でのコード更新
-
-### 次のステップ
-
-- Phoenix フレームワークでの Web 開発
-- Ecto でのデータベース操作
-- LiveView でのリアルタイム UI
-- Nerves での組み込み開発
-- 実際のプロジェクトで FP を適用する
+# Part VI: 実践的なアプリケーション構築とテスト
+
+本章では、これまで学んだ関数型プログラミングの概念を統合し、実践的なアプリケーションを構築します。また、関数型プログラミングにおけるテスト戦略についても学びます。
+
+---
+
+## 第12章: 実践的なアプリケーションとテスト戦略
+
+### 12.1 TravelGuide アプリケーション
+
+旅行ガイドアプリケーションを例に、実践的な FP アプリケーションの構築方法を学びます。
+
+```plantuml
+@startuml
+!theme plain
+
+package "TravelGuide Application" {
+  rectangle "Model" {
+    class Location {
+      id: LocationId
+      name: String
+      population: integer
+    }
+
+    class Attraction {
+      name: String
+      description: String | nil
+      location: Location
+    }
+
+    class TravelGuide {
+      attraction: Attraction
+      subjects: [String]
+      search_report: SearchReport
+    }
+  }
+
+  rectangle "Data Access" {
+    interface DataAccess {
+      +find_attractions(): {:ok, [Attraction]} | {:error, String}
+      +find_artists_from_location(): {:ok, [MusicArtist]} | {:error, String}
+      +find_movies_about_location(): {:ok, [Movie]} | {:error, String}
+    }
+
+    class TestDataAccess
+    class CachedDataAccess
+  }
+
+  DataAccess <|.. TestDataAccess
+  DataAccess <|.. CachedDataAccess
+}
+
+@enduml
+```
+
+### 12.2 ドメインモデルの定義
+
+**ソースファイル**: `app/elixir/lib/ch12/travel_guide.ex`
+
+Elixir では構造体（struct）を使ってドメインモデルを定義します。
+
+```elixir
+defmodule LocationId do
+  @moduledoc "位置情報 ID（Value Object）"
+  defstruct [:value]
+
+  @type t :: %__MODULE__{value: String.t()}
+
+  @spec new(String.t()) :: t()
+  def new(value), do: %__MODULE__{value: value}
+end
+
+defmodule Location do
+  @moduledoc "ロケーション"
+  defstruct [:id, :name, :population]
+
+  @type t :: %__MODULE__{
+          id: LocationId.t(),
+          name: String.t(),
+          population: non_neg_integer()
+        }
+
+  @spec new(LocationId.t(), String.t(), non_neg_integer()) :: t()
+  def new(id, name, population) do
+    %__MODULE__{id: id, name: name, population: population}
+  end
+end
+
+defmodule Attraction do
+  @moduledoc "アトラクション（観光地）"
+  defstruct [:name, :description, :location]
+
+  @type t :: %__MODULE__{
+          name: String.t(),
+          description: String.t() | nil,
+          location: Location.t()
+        }
+
+  @spec new(String.t(), String.t() | nil, Location.t()) :: t()
+  def new(name, description, location) do
+    %__MODULE__{name: name, description: description, location: location}
+  end
+end
+```
+
+### 12.3 データアクセス層の抽象化
+
+Elixir では `@behaviour` を使用してインターフェースを定義します。
+
+```elixir
+defmodule DataAccess do
+  @moduledoc """
+  データアクセス層のインターフェース（振る舞い）
+
+  実装モジュールはこの振る舞いを実装する必要がある。
+  """
+
+  @type ordering :: :by_name | :by_location_population
+
+  @callback find_attractions(String.t(), ordering(), pos_integer()) ::
+              {:ok, [Attraction.t()]} | {:error, String.t()}
+
+  @callback find_artists_from_location(LocationId.t(), pos_integer()) ::
+              {:ok, [MusicArtist.t()]} | {:error, String.t()}
+
+  @callback find_movies_about_location(LocationId.t(), pos_integer()) ::
+              {:ok, [Movie.t()]} | {:error, String.t()}
+
+  @callback find_hotels_near_location(LocationId.t(), pos_integer()) ::
+              {:ok, [Hotel.t()]} | {:error, String.t()}
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+
+interface DataAccess {
+  +find_attractions(): {:ok, [Attraction]} | {:error, String}
+  +find_artists_from_location(): {:ok, [MusicArtist]} | {:error, String}
+  +find_movies_about_location(): {:ok, [Movie]} | {:error, String}
+}
+
+note right of DataAccess
+  @behaviour による振る舞い定義
+  実装モジュールは @impl true で実装
+end note
+
+class TestDataAccess {
+  +find_attractions(): {:ok, [Attraction]}
+  +find_artists_from_location(): {:ok, [MusicArtist]}
+  +find_movies_about_location(): {:ok, [Movie]}
+}
+
+class FailingDataAccess {
+  +find_attractions(): {:ok, [Attraction]}
+  +find_artists_from_location(): {:error, String}
+  +find_movies_about_location(): {:error, String}
+}
+
+DataAccess <|.. TestDataAccess
+DataAccess <|.. FailingDataAccess
+
+@enduml
+```
+
+### 12.4 スタブ実装
+
+テスト用のスタブ実装を作成します。
+
+```elixir
+defmodule TestDataAccess do
+  @moduledoc "テスト用のスタブ実装"
+  @behaviour DataAccess
+
+  @impl true
+  def find_attractions(name, _ordering, limit) do
+    attractions =
+      case name do
+        "Empty" -> []
+        _ ->
+          [
+            Attraction.new("#{name} Tower", "A famous tower", @test_location),
+            Attraction.new("#{name} Park", "A beautiful park", @test_location),
+            Attraction.new("#{name} Museum", "A great museum", @test_location)
+          ]
+      end
+
+    {:ok, Enum.take(attractions, limit)}
+  end
+
+  @impl true
+  def find_artists_from_location(_location_id, limit) do
+    artists = [
+      MusicArtist.new("Test Artist 1", "Pop"),
+      MusicArtist.new("Test Artist 2", "Rock")
+    ]
+
+    {:ok, Enum.take(artists, limit)}
+  end
+
+  # 他のコールバックも同様に実装...
+end
+```
+
+### 12.5 Agent を使用したキャッシュ
+
+Elixir の Agent を使用して、スレッドセーフなキャッシュを実装します。
+
+```elixir
+defmodule CachedDataAccess do
+  @moduledoc """
+  Agent を使ったキャッシュ付きデータアクセス
+  """
+
+  @spec start_link(module()) :: {:ok, pid()}
+  def start_link(data_access_module) do
+    Agent.start_link(fn ->
+      %{
+        module: data_access_module,
+        attractions_cache: %{},
+        artists_cache: %{},
+        movies_cache: %{},
+        hotels_cache: %{}
+      }
+    end)
+  end
+
+  @spec find_attractions(pid(), String.t(), DataAccess.ordering(), pos_integer()) ::
+          {:ok, [Attraction.t()]} | {:error, String.t()}
+  def find_attractions(cache, name, ordering, limit) do
+    key = "#{name}-#{ordering}-#{limit}"
+
+    Agent.get_and_update(cache, fn state ->
+      case Map.get(state.attractions_cache, key) do
+        nil ->
+          result = state.module.find_attractions(name, ordering, limit)
+
+          case result do
+            {:ok, attractions} ->
+              new_cache = Map.put(state.attractions_cache, key, attractions)
+              {result, %{state | attractions_cache: new_cache}}
+
+            {:error, _} = error ->
+              {error, state}
+          end
+
+        cached ->
+          {{:ok, cached}, state}
+      end
+    end)
+  end
+
+  # 他のメソッドも同様に実装...
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+skinparam activity {
+  BackgroundColor White
+  BorderColor Black
+}
+
+start
+
+:キャッシュキー生成;
+
+:Agent.get_and_update でキャッシュ確認;
+
+if (キャッシュにデータあり?) then (yes)
+  :キャッシュからデータ返却;
+else (no)
+  :外部モジュールを呼び出し;
+  :結果をキャッシュに保存;
+  :結果を返却;
+endif
+
+stop
+
+note right
+  Agent を使用した
+  スレッドセーフなキャッシュ
+end note
+
+@enduml
+```
+
+### 12.6 アプリケーションの組み立て
+
+すべてのコンポーネントを組み合わせてアプリケーションを構築します。
+
+```elixir
+@spec travel_guide(module(), String.t()) :: {:ok, TravelGuide.t()} | {:error, String.t()}
+def travel_guide(data_access_module, attraction_name) do
+  case data_access_module.find_attractions(attraction_name, :by_location_population, 1) do
+    {:ok, []} ->
+      {:error, "No attractions found"}
+
+    {:ok, [attraction | _]} ->
+      build_guide(data_access_module, attraction, 1)
+
+    {:error, reason} ->
+      {:error, reason}
+  end
+end
+
+defp build_guide(data_access_module, attraction, attractions_searched) do
+  location_id = attraction.location.id
+
+  artists_result = data_access_module.find_artists_from_location(location_id, 2)
+  movies_result = data_access_module.find_movies_about_location(location_id, 2)
+
+  errors =
+    [artists_result, movies_result]
+    |> Enum.filter(&match?({:error, _}, &1))
+    |> Enum.map(fn {:error, reason} -> reason end)
+
+  artists =
+    case artists_result do
+      {:ok, list} -> list
+      {:error, _} -> []
+    end
+
+  movies =
+    case movies_result do
+      {:ok, list} -> list
+      {:error, _} -> []
+    end
+
+  subjects = Enum.map(artists, & &1.name) ++ Enum.map(movies, & &1.name)
+  report = SearchReport.new(attractions_searched, errors)
+
+  {:ok, TravelGuide.new(attraction, subjects, report)}
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "travel_guide 関数" {
+  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
+  パターンマッチングで
+  複数の結果を合成
+end note
+
+@enduml
+```
+
+### 12.7 SearchReport の導入
+
+テスト可能性を高めるため、`SearchReport` を導入します。
+
+**ソースファイル**: `app/elixir/lib/ch12/travel_guide.ex`
+
+```elixir
+defmodule SearchReport do
+  @moduledoc "検索レポート"
+  defstruct [:attractions_searched, :errors]
+
+  @type t :: %__MODULE__{
+          attractions_searched: non_neg_integer(),
+          errors: [String.t()]
+        }
+
+  @spec new(non_neg_integer(), [String.t()]) :: t()
+  def new(attractions_searched, errors \\ []) do
+    %__MODULE__{attractions_searched: attractions_searched, errors: errors}
+  end
+
+  @spec empty() :: t()
+  def empty, do: new(0, [])
+
+  @spec add_error(t(), String.t()) :: t()
+  def add_error(%__MODULE__{} = report, error) do
+    %{report | errors: report.errors ++ [error]}
+  end
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+
+class TravelGuide {
+  attraction: Attraction
+  subjects: [String]
+  search_report: SearchReport
+}
+
+class SearchReport {
+  attractions_searched: integer
+  errors: [String]
+}
+
+TravelGuide --> SearchReport
+
+note right of SearchReport
+  検索の統計情報と
+  エラー情報を保持
+end note
+
+@enduml
+```
+
+---
+
+## テスト戦略
+
+### 12.8 関数型プログラミングのテスト
+
+関数型プログラミングでは、純粋関数のおかげでテストが非常に簡単になります。
+
+```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.9 純粋関数のテスト
+
+**ソースファイル**: `app/elixir/lib/ch12/testing.ex`
+
+純粋関数は入力と出力だけを考えればよいため、テストが簡単です。
+
+```elixir
+# テスト対象の純粋関数
+@spec filter_popular_locations([Location.t()], non_neg_integer()) :: [Location.t()]
+def filter_popular_locations(locations, min_population) do
+  Enum.filter(locations, fn loc -> loc.population >= min_population end)
+end
+
+@spec sort_by_population([Attraction.t()]) :: [Attraction.t()]
+def sort_by_population(attractions) do
+  Enum.sort_by(attractions, fn a -> a.location.population end, :desc)
+end
+
+@spec aggregate_results([{:ok, any()} | {:error, String.t()}]) ::
+        {[any()], [String.t()]}
+def aggregate_results(results) do
+  Enum.reduce(results, {[], []}, fn result, {successes, errors} ->
+    case result do
+      {:ok, value} -> {successes ++ [value], errors}
+      {:error, reason} -> {successes, errors ++ [reason]}
+    end
+  end)
+end
+```
+
+### 12.10 プロパティベーステスト
+
+**ソースファイル**: `app/elixir/lib/ch12/testing.ex`
+
+ランダムな入力を生成して不変条件をテストします。
+
+```elixir
+@doc """
+プロパティをテスト（指定回数実行）
+"""
+@spec check_property(pos_integer(), (-> boolean())) :: :ok | {:error, String.t()}
+def check_property(iterations, property_fn) do
+  results =
+    Enum.map(1..iterations, fn _ ->
+      try do
+        property_fn.()
+      rescue
+        _ -> false
+      end
+    end)
+
+  if Enum.all?(results) do
+    :ok
+  else
+    failed_count = Enum.count(results, &(!&1))
+    {:error, "Property failed #{failed_count}/#{iterations} times"}
+  end
+end
+
+@doc """
+filter_popular_locations の不変条件をテスト
+"""
+@spec verify_filter_properties(pos_integer()) :: :ok | {:error, String.t()}
+def verify_filter_properties(iterations) do
+  check_property(iterations, fn ->
+    locations = random_locations(:rand.uniform(20))
+    min_population = random_positive_int(5_000_000)
+
+    result = TravelGuide.filter_popular_locations(locations, min_population)
+
+    # プロパティ1: 結果のサイズは入力以下
+    size_property = length(result) <= length(locations)
+
+    # プロパティ2: 結果のすべての要素は条件を満たす
+    all_meet_condition = Enum.all?(result, fn loc -> loc.population >= min_population end)
+
+    # プロパティ3: 条件を満たす要素はすべて結果に含まれる
+    qualifying = Enum.filter(locations, fn loc -> loc.population >= min_population end)
+    all_included = Enum.all?(qualifying, fn loc -> loc in result end)
+
+    size_property and all_meet_condition and all_included
+  end)
+end
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "プロパティベーステスト" {
+  card "random_location/0" as gen
+  card "ランダムデータ生成" as random
+  card "プロパティ検証" as verify
+  card "N回繰り返しテスト" as repeat
+
+  gen --> random
+  random --> verify
+  verify --> repeat
+  repeat --> random : 繰り返し
+}
+
+note bottom
+  ランダムな入力で
+  不変条件を検証
+end note
+
+@enduml
+```
+
+### 12.11 ランダムデータ生成
+
+```elixir
+@doc """
+ランダムな文字列を生成
+"""
+@spec random_string(pos_integer()) :: String.t()
+def random_string(length) do
+  :crypto.strong_rand_bytes(length)
+  |> Base.encode64()
+  |> binary_part(0, length)
+end
+
+@doc """
+ランダムな Location を生成
+"""
+@spec random_location() :: Location.t()
+def random_location do
+  id = LocationId.new("Q#{random_positive_int(1_000_000)}")
+  name = random_string(8)
+  population = random_positive_int(10_000_000)
+  Location.new(id, name, population)
+end
+
+@doc """
+ランダムな Attraction を生成
+"""
+@spec random_attraction() :: Attraction.t()
+def random_attraction do
+  name = random_string(10)
+  description = if :rand.uniform(2) == 1, do: random_string(20), else: nil
+  location = random_location()
+  Attraction.new(name, description, location)
+end
+```
+
+### 12.12 統合テスト
+
+```elixir
+@doc """
+TravelGuide の統合テストを実行
+"""
+@spec run_integration_tests() :: {:ok, map()}
+def run_integration_tests do
+  tests = [
+    {:normal_case, fn ->
+      case TravelGuide.travel_guide(TravelGuide.TestDataAccess, "Tokyo") do
+        {:ok, guide} ->
+          guide.attraction.name == "Tokyo Tower" and
+            length(guide.subjects) > 0 and
+            guide.search_report.errors == []
+
+        _ ->
+          false
+      end
+    end},
+    {:empty_result, fn ->
+      case TravelGuide.travel_guide(TravelGuide.TestDataAccess, "Empty") do
+        {:error, "No attractions found"} -> true
+        _ -> false
+      end
+    end},
+    {:error_handling, fn ->
+      case TravelGuide.travel_guide(TravelGuide.FailingDataAccess, "Test") do
+        {:ok, guide} ->
+          length(guide.search_report.errors) == 2
+
+        _ ->
+          false
+      end
+    end},
+    {:cached_access, fn ->
+      {:ok, cache} = TravelGuide.CachedDataAccess.start_link(TravelGuide.TestDataAccess)
+
+      result1 = TravelGuide.travel_guide_cached(cache, "Tokyo")
+      result2 = TravelGuide.travel_guide_cached(cache, "Tokyo")
+
+      stats = TravelGuide.CachedDataAccess.cache_stats(cache)
+      Agent.stop(cache)
+
+      case {result1, result2} do
+        {{:ok, g1}, {:ok, g2}} ->
+          g1.attraction.name == g2.attraction.name and
+            stats.attractions > 0
+
+        _ ->
+          false
+      end
+    end}
+  ]
+
+  results =
+    Enum.map(tests, fn {name, test_fn} ->
+      result =
+        try do
+          test_fn.()
+        rescue
+          _ -> false
+        end
+
+      {name, result}
+    end)
+
+  passed = Enum.count(results, fn {_, r} -> r end)
+  failed = Enum.count(results, fn {_, r} -> !r end)
+
+  {:ok, %{passed: passed, failed: failed, results: results}}
+end
+```
+
+```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
+    class "FailingDataAccess" as fda
+    da2 <|.. tda
+    da2 <|.. fda
+  }
+}
+
+note bottom of prod
+  実際の外部 API に接続
+end note
+
+note bottom of test
+  テストデータを返す
+  即座に結果を返す
+end note
+
+@enduml
+```
+
+### 12.13 パフォーマンステスト
+
+```elixir
+@doc """
+関数の実行時間を計測
+"""
+@spec measure_time((-> any())) :: {non_neg_integer(), any()}
+def measure_time(fun) do
+  {time, result} = :timer.tc(fun)
+  {time, result}
+end
+
+@doc """
+キャッシュの効果を測定
+"""
+@spec measure_cache_effect(pos_integer()) :: {:ok, map()}
+def measure_cache_effect(iterations) do
+  # キャッシュなしの時間
+  {uncached_time, _} =
+    measure_time(fn ->
+      Enum.each(1..iterations, fn _ ->
+        TravelGuide.travel_guide(TravelGuide.TestDataAccess, "Tokyo")
+      end)
+    end)
+
+  # キャッシュありの時間
+  {:ok, cache} = TravelGuide.CachedDataAccess.start_link(TravelGuide.TestDataAccess)
+
+  {cached_time, _} =
+    measure_time(fn ->
+      Enum.each(1..iterations, fn _ ->
+        TravelGuide.travel_guide_cached(cache, "Tokyo")
+      end)
+    end)
+
+  Agent.stop(cache)
+
+  {:ok,
+   %{
+     uncached_time: uncached_time,
+     cached_time: cached_time,
+     speedup: uncached_time / max(cached_time, 1)
+   }}
+end
+```
+
+### 12.14 テストピラミッド
+
+```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 "ドメインモデル" as model {
+    card "構造体による型定義"
+    card "Value Object パターン"
+  }
+
+  rectangle "データアクセス" as data {
+    card "@behaviour による抽象化"
+    card "スタブ実装"
+    card "Agent によるキャッシュ"
+  }
+
+  rectangle "テスト戦略" as test {
+    card "純粋関数のテスト"
+    card "プロパティベーステスト"
+    card "統合テスト"
+  }
+}
+
+model --> data
+data --> test
+
+@enduml
+```
+
+### キーポイント
+
+1. **@behaviour による抽象化**: DataAccess 振る舞いで外部依存を抽象化
+2. **Agent でキャッシュ**: スレッドセーフな状態管理
+3. **タプルでエラー処理**: `{:ok, value}` / `{:error, reason}` で明示的なエラーハンドリング
+4. **SearchReport**: テスト可能性と可観測性の向上
+5. **スタブ**: 外部依存を差し替えてテスト
+6. **プロパティベーステスト**: ランダム入力で不変条件を検証
+
+### Scala との対比
+
+| 概念 | Scala | Elixir |
+|------|-------|--------|
+| インターフェース | `trait` | `@behaviour` |
+| 状態管理 | `Ref[IO, A]` | `Agent` |
+| リソース管理 | `Resource[IO, A]` | プロセス / `with` |
+| エラー処理 | `Either[E, A]` | `{:ok, a} \| {:error, e}` |
+| 非同期処理 | `IO[A]` | `Task` / `GenServer` |
+| キャッシュ | `Ref` + `Map` | `Agent` + `Map` |
+
+### 学習の総括
+
+```plantuml
+@startuml
+!theme plain
+left to right direction
+
+rectangle "Elixir FP の学習パス" {
+  card "Part I\n基礎" as p1
+  card "Part II\nイミュータブル操作" as p2
+  card "Part III\n型とパターン" as p3
+  card "Part IV\nStream と再帰" as p4
+  card "Part V\n並行処理・OTP" as p5
+  card "Part VI\n実践" as p6
+}
+
+p1 --> p2
+p2 --> p3
+p3 --> p4
+p4 --> p5
+p5 --> p6
+
+@enduml
+```
+
+---
+
+## 演習問題
+
+### 問題 1: DataAccess の拡張
+
+以下の要件で `DataAccess` を拡張してください:
+
+
+- 新しいコールバック `find_restaurants_near_location` を追加
+- 戻り値は `{:ok, [Restaurant.t()]} | {:error, String.t()}`
+
+<details>
+<summary>解答</summary>
+
+```elixir
+defmodule Restaurant do
+  defstruct [:name, :cuisine, :rating, :location]
+
+  @type t :: %__MODULE__{
+          name: String.t(),
+          cuisine: String.t(),
+          rating: float(),
+          location: Location.t()
+        }
+
+  @spec new(String.t(), String.t(), float(), Location.t()) :: t()
+  def new(name, cuisine, rating, location) do
+    %__MODULE__{name: name, cuisine: cuisine, rating: rating, location: location}
+  end
+end
+
+# DataAccess に追加
+@callback find_restaurants_near_location(LocationId.t(), pos_integer()) ::
+            {:ok, [Restaurant.t()]} | {:error, String.t()}
+
+# TestDataAccess の実装
+@impl true
+def find_restaurants_near_location(_location_id, limit) do
+  restaurants = [
+    Restaurant.new("Test Restaurant 1", "Japanese", 4.5, @test_location),
+    Restaurant.new("Test Restaurant 2", "Italian", 4.0, @test_location)
+  ]
+
+  {:ok, Enum.take(restaurants, limit)}
+end
+```
+
+</details>
+
+### 問題 2: プロパティベーステスト
+
+以下の関数に対するプロパティベーステストを書いてください:
+
+```elixir
+def merge_subjects(artists, movies) do
+  Enum.map(artists, & &1.name) ++ Enum.map(movies, & &1.name)
+end
+```
+
+<details>
+<summary>解答</summary>
+
+```elixir
+@spec verify_merge_properties(pos_integer()) :: :ok | {:error, String.t()}
+def verify_merge_properties(iterations) do
+  check_property(iterations, fn ->
+    artist_count = :rand.uniform(10)
+    movie_count = :rand.uniform(10)
+
+    artists = Enum.map(1..artist_count, fn i ->
+      MusicArtist.new("Artist #{i}", nil)
+    end)
+
+    movies = Enum.map(1..movie_count, fn i ->
+      Movie.new("Movie #{i}", nil)
+    end)
+
+    result = TravelGuide.merge_subjects(artists, movies)
+
+    # プロパティ1: 結果の長さは入力の合計
+    length_property = length(result) == artist_count + movie_count
+
+    # プロパティ2: すべてのアーティスト名が含まれる
+    artist_names = Enum.map(artists, & &1.name)
+    artists_included = Enum.all?(artist_names, fn n -> n in result end)
+
+    # プロパティ3: すべての映画名が含まれる
+    movie_names = Enum.map(movies, & &1.name)
+    movies_included = Enum.all?(movie_names, fn n -> n in result end)
+
+    length_property and artists_included and movies_included
+  end)
+end
+```
+
+</details>
+
+### 問題 3: キャッシュの有効期限
+
+`CachedDataAccess` にキャッシュの有効期限機能を追加してください。
+
+<details>
+<summary>解答</summary>
+
+```elixir
+defmodule CachedDataAccessWithTTL do
+  @moduledoc """
+  TTL（有効期限）付きキャッシュ
+  """
+
+  @default_ttl_ms 60_000  # 60秒
+
+  @spec start_link(module(), pos_integer()) :: {:ok, pid()}
+  def start_link(data_access_module, ttl_ms \\ @default_ttl_ms) do
+    Agent.start_link(fn ->
+      %{
+        module: data_access_module,
+        ttl_ms: ttl_ms,
+        attractions_cache: %{}  # key => {value, timestamp}
+      }
+    end)
+  end
+
+  @spec find_attractions(pid(), String.t(), DataAccess.ordering(), pos_integer()) ::
+          {:ok, [Attraction.t()]} | {:error, String.t()}
+  def find_attractions(cache, name, ordering, limit) do
+    key = "#{name}-#{ordering}-#{limit}"
+    now = System.monotonic_time(:millisecond)
+
+    Agent.get_and_update(cache, fn state ->
+      case Map.get(state.attractions_cache, key) do
+        {cached, timestamp} when now - timestamp < state.ttl_ms ->
+          # キャッシュが有効
+          {{:ok, cached}, state}
+
+        _ ->
+          # キャッシュが無効または存在しない
+          result = state.module.find_attractions(name, ordering, limit)
+
+          case result do
+            {:ok, attractions} ->
+              new_cache = Map.put(state.attractions_cache, key, {attractions, now})
+              {result, %{state | attractions_cache: new_cache}}
+
+            {:error, _} = error ->
+              {error, state}
+          end
+      end
+    end)
+  end
+end
+```
+
+</details>
+
+---
+
+## シリーズ全体の総括
+
+本シリーズでは、「Grokking Functional Programming」の内容に沿って、Elixir による関数型プログラミングの基礎から実践的なアプリケーション構築までを学びました。
+
+### 学んだ主な概念
+
+| Part | 章 | 主な概念 |
+|------|-----|----------|
+| I | 1-2 | 純粋関数、イミュータビリティ |
+| II | 3-5 | パイプ演算子、高階関数、Enum |
+| III | 6-7 | パターンマッチング、with 式 |
+| IV | 8-9 | Stream、再帰 |
+| V | 10-11 | 並行処理、OTP パターン |
+| VI | 12 | 実践アプリケーション、テスト |
+
+### 関数型プログラミングの利点
+
+1. **予測可能性**: 純粋関数は同じ入力に対して常に同じ出力
+2. **テスト容易性**: 副作用がないためテストが簡単
+3. **合成可能性**: パイプ演算子で小さな関数を組み合わせ
+4. **並行安全性**: イミュータブルデータは競合状態を防ぐ
+5. **パターンマッチング**: 明確で安全なデータ処理
+
+### Elixir 特有の利点
+
+1. **OTP**: 堅牢な並行処理フレームワーク
+2. **BEAM VM**: 軽量プロセスと高いスケーラビリティ
+3. **パイプ演算子**: 読みやすいデータ変換
+4. **パターンマッチング**: 強力な分岐とデストラクチャリング
+5. **ホットコードスワップ**: 無停止でのコード更新
+
+### 次のステップ
+
+- Phoenix フレームワークでの Web 開発
+- Ecto でのデータベース操作
+- LiveView でのリアルタイム UI
+- Nerves での組み込み開発
+- 実際のプロジェクトで FP を適用する