@k2works/claude-code-booster 2.7.1 → 3.1.0

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

@@ -0,0 +1,1047 @@
+# 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 を適用する