@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/elixir/20-pattern-interactions.md

@@ -0,0 +1,287 @@
+# 第20章: パターン間の相互作用
+
+## はじめに
+
+関数型設計パターンは単独で使用するよりも、組み合わせることでより強力になります。この章では、複数のパターンを統合して複雑な問題を解決する方法を学びます。
+
+## 1. Visitor + Iterator パターン
+
+### 木構造の走査と処理
+
+```elixir
+defmodule TreeNode do
+  defstruct [:value, :left, :right]
+
+  def leaf(value), do: %__MODULE__{value: value}
+  def node(value, left, right), do: %__MODULE__{value: value, left: left, right: right}
+end
+
+# イテレータ: 走査戦略
+defmodule Iterator do
+  def preorder(nil), do: []
+  def preorder(%TreeNode{value: v, left: l, right: r}) do
+    [v | preorder(l) ++ preorder(r)]
+  end
+
+  def inorder(nil), do: []
+  def inorder(%TreeNode{value: v, left: l, right: r}) do
+    inorder(l) ++ [v] ++ inorder(r)
+  end
+end
+
+# ビジター: 要素への操作
+defmodule Visitor do
+  def sum(values), do: Enum.sum(values)
+  def max(values), do: Enum.max(values)
+  def map(values, func), do: Enum.map(values, func)
+end
+```
+
+### 組み合わせて使用
+
+```elixir
+def traverse_and_visit(tree, iterator_fn, visitor_fn) do
+  tree
+  |> iterator_fn.()
+  |> visitor_fn.()
+end
+
+# 使用例
+tree
+|> traverse_and_visit(&Iterator.inorder/1, &Visitor.sum/1)
+```
+
+## 2. Strategy + Factory パターン
+
+### 動的な戦略生成
+
+```elixir
+defmodule DiscountFactory do
+  def create(:regular), do: &regular_discount/1
+  def create(:premium), do: &premium_discount/1
+  def create(:vip), do: &vip_discount/1
+  def create({:seasonal, rate}), do: fn price -> price * (1 - rate) end
+  def create({:combined, strategies}) do
+    fn price ->
+      Enum.reduce(strategies, price, fn s, acc -> create(s).(acc) end)
+    end
+  end
+
+  defp regular_discount(price), do: price
+  defp premium_discount(price), do: price * 0.9
+  defp vip_discount(price), do: price * 0.8
+end
+
+# 使用例
+strategy = DiscountFactory.create({:combined, [:premium, {:seasonal, 0.1}]})
+final_price = strategy.(100.0)  # 81.0
+```
+
+## 3. Observer + State パターン
+
+### 状態変化の通知
+
+```elixir
+defmodule OrderStateMachine do
+  use GenServer
+
+  @transitions %{
+    pending: [:confirmed, :cancelled],
+    confirmed: [:shipped, :cancelled],
+    shipped: [:delivered]
+  }
+
+  def transition(pid, new_state) do
+    GenServer.call(pid, {:transition, new_state})
+  end
+
+  @impl true
+  def handle_call({:transition, new_state}, _from, state) do
+    allowed = Map.get(@transitions, state.current, [])
+
+    if new_state in allowed do
+      # オブザーバーに通知
+      notify_observers(state.observers, %{
+        old_state: state.current,
+        new_state: new_state
+      })
+      {:reply, {:ok, new_state}, %{state | current: new_state}}
+    else
+      {:reply, {:error, :invalid_transition}, state}
+    end
+  end
+
+  defp notify_observers(observers, event) do
+    Enum.each(observers, fn {_id, handler} -> handler.(event) end)
+  end
+end
+```
+
+## 4. Decorator + Pipeline パターン
+
+### 処理の動的拡張
+
+```elixir
+defmodule DecoratorPipeline do
+  def with_logging(func, label) do
+    fn input ->
+      IO.puts("[#{label}] Input: #{inspect(input)}")
+      result = func.(input)
+      IO.puts("[#{label}] Output: #{inspect(result)}")
+      result
+    end
+  end
+
+  def with_timing(func) do
+    fn input ->
+      start = System.monotonic_time(:microsecond)
+      result = func.(input)
+      elapsed = System.monotonic_time(:microsecond) - start
+      {result, elapsed}
+    end
+  end
+
+  def with_error_handling(func, default \\ nil) do
+    fn input ->
+      try do
+        {:ok, func.(input)}
+      rescue
+        e -> {:error, e, default}
+      end
+    end
+  end
+end
+
+# パイプラインビルダー
+defmodule PipelineBuilder do
+  defstruct steps: []
+
+  def new, do: %__MODULE__{}
+
+  def add_step(builder, step) do
+    %{builder | steps: builder.steps ++ [step]}
+  end
+
+  def build(builder, base_func) do
+    Enum.reduce(builder.steps, base_func, fn decorator, func ->
+      decorator.(func)
+    end)
+  end
+end
+```
+
+## 5. Composite + Visitor パターン
+
+### ファイルシステムの例
+
+```elixir
+defmodule FileSystem do
+  defmodule File do
+    defstruct [:name, :size]
+  end
+
+  defmodule Directory do
+    defstruct [:name, children: []]
+  end
+
+  # ビジター: 合計サイズ
+  def total_size(%File{size: size}), do: size
+  def total_size(%Directory{children: children}) do
+    children |> Enum.map(&total_size/1) |> Enum.sum()
+  end
+
+  # ビジター: ファイル数
+  def file_count(%File{}), do: 1
+  def file_count(%Directory{children: children}) do
+    children |> Enum.map(&file_count/1) |> Enum.sum()
+  end
+
+  # ビジター: パターンマッチでファイル検索
+  def find_files(%File{name: name} = file, pattern) do
+    if String.match?(name, pattern), do: [file], else: []
+  end
+  def find_files(%Directory{children: children}, pattern) do
+    children |> Enum.flat_map(&find_files(&1, pattern))
+  end
+end
+```
+
+### 式の評価
+
+```elixir
+defmodule Expression do
+  defmodule Number do
+    defstruct [:value]
+  end
+
+  defmodule BinaryOp do
+    defstruct [:op, :left, :right]
+  end
+
+  # 評価ビジター
+  def evaluate(%Number{value: v}), do: v
+  def evaluate(%BinaryOp{op: :add, left: l, right: r}) do
+    evaluate(l) + evaluate(r)
+  end
+  def evaluate(%BinaryOp{op: :mul, left: l, right: r}) do
+    evaluate(l) * evaluate(r)
+  end
+
+  # 文字列化ビジター
+  def stringify(%Number{value: v}), do: "#{v}"
+  def stringify(%BinaryOp{op: op, left: l, right: r}) do
+    "(#{stringify(l)} #{op_symbol(op)} #{stringify(r)})"
+  end
+
+  defp op_symbol(:add), do: "+"
+  defp op_symbol(:mul), do: "*"
+end
+```
+
+## 6. 統合例: 注文処理システム
+
+```elixir
+defmodule OrderProcessor do
+  alias DiscountFactory
+  alias ValidatorFactory
+
+  defstruct [:customer_type, :items, :validators]
+
+  def new(customer_type) do
+    %__MODULE__{customer_type: customer_type, items: [], validators: []}
+  end
+
+  def add_item(processor, name, price) do
+    %{processor | items: [{name, price} | processor.items]}
+  end
+
+  def add_validator(processor, validator_type) do
+    %{processor | validators: [validator_type | processor.validators]}
+  end
+
+  def calculate_total(processor) do
+    strategy = DiscountFactory.create(processor.customer_type)
+    processor.items
+    |> Enum.map(fn {_name, price} -> strategy.(price) end)
+    |> Enum.sum()
+  end
+
+  def process(processor) do
+    # パイプラインで処理
+    PipelineBuilder.new()
+    |> PipelineBuilder.add_error_handling(0.0)
+    |> PipelineBuilder.execute(fn _ -> calculate_total(processor) end, processor)
+  end
+end
+```
+
+## まとめ
+
+パターンの組み合わせにより、以下が実現できます：
+
+1. **柔軟性**: 異なる走査戦略と処理を組み合わせ
+2. **再利用性**: 共通のビルディングブロックを様々な文脈で使用
+3. **拡張性**: デコレータで既存の処理を拡張
+4. **型安全性**: パターンマッチによる堅牢な処理分岐
+
+パターンを単独で理解した後は、組み合わせて使う練習が重要です。

package/lib/assets/docs/article/functional-desgin-ppp/elixir/21-best-practices.md

@@ -0,0 +1,340 @@
+# 第21章: ベストプラクティス
+
+## はじめに
+
+関数型プログラミングのベストプラクティスを実践的な例とともに解説します。良いコードと改善が必要なコードを比較しながら学びます。
+
+## 1. 不変性と純粋関数
+
+### 悪い例: 外部状態への依存
+
+```elixir
+# ❌ 純粋関数ではない
+def get_current_time_greeting do
+  hour = DateTime.utc_now().hour
+  cond do
+    hour < 12 -> "Good morning"
+    hour < 18 -> "Good afternoon"
+    true -> "Good evening"
+  end
+end
+```
+
+### 良い例: 依存性の注入
+
+```elixir
+# ✅ 純粋関数
+def greeting_for_hour(hour) when hour >= 0 and hour < 24 do
+  cond do
+    hour < 12 -> "Good morning"
+    hour < 18 -> "Good afternoon"
+    true -> "Good evening"
+  end
+end
+
+# 不純なラッパー
+def current_greeting do
+  greeting_for_hour(DateTime.utc_now().hour)
+end
+```
+
+### 不変データの操作
+
+```elixir
+# マップの安全な更新
+def update_user(user, updates) do
+  Map.merge(user, updates)
+end
+
+# ネストしたデータの更新
+def update_nested(data, path, func) do
+  update_in(data, path, func)
+end
+
+# リストへの追加（先頭が効率的）
+def prepend(list, item), do: [item | list]
+```
+
+## 2. パイプラインと関数合成
+
+### 悪い例: ネストした関数呼び出し
+
+```elixir
+# ❌ 読みにくい
+def process(data) do
+  Enum.join(
+    Enum.map(
+      Enum.filter(
+        String.split(data, ","),
+        fn s -> String.length(String.trim(s)) > 0 end
+      ),
+      &String.upcase(String.trim(&1))
+    ),
+    " | "
+  )
+end
+```
+
+### 良い例: パイプライン
+
+```elixir
+# ✅ 読みやすい
+def process(data) do
+  data
+  |> String.split(",")
+  |> Enum.map(&String.trim/1)
+  |> Enum.filter(&(String.length(&1) > 0))
+  |> Enum.map(&String.upcase/1)
+  |> Enum.join(" | ")
+end
+```
+
+### 関数合成
+
+```elixir
+# 複数の関数を合成
+def pipe_compose(functions) do
+  fn x ->
+    Enum.reduce(functions, x, fn f, acc -> f.(acc) end)
+  end
+end
+
+# 使用例
+pipeline = pipe_compose([
+  fn x -> x + 1 end,
+  fn x -> x * 2 end
+])
+pipeline.(5)  # => 12
+```
+
+## 3. エラーハンドリング
+
+### タグ付きタプル
+
+```elixir
+# 成功/失敗を明示的に返す
+def divide(a, b) when b != 0, do: {:ok, a / b}
+def divide(_a, 0), do: {:error, :division_by_zero}
+
+# nilの代わりにタグ付きタプル
+def find_user(users, id) do
+  case Enum.find(users, &(&1.id == id)) do
+    nil -> {:error, :not_found}
+    user -> {:ok, user}
+  end
+end
+```
+
+### with構文
+
+```elixir
+def process_order(order_id, user_id, users, orders) do
+  with {:ok, user} <- find_user(users, user_id),
+       {:ok, order} <- find_order(orders, order_id),
+       :ok <- validate_owner(user, order) do
+    {:ok, %{user: user, order: order}}
+  end
+end
+```
+
+### Railway Oriented Programming
+
+```elixir
+defmodule Railway do
+  def bind({:ok, value}, func), do: func.(value)
+  def bind({:error, _} = error, _func), do: error
+
+  def pipeline(value, functions) do
+    Enum.reduce(functions, {:ok, value}, fn func, acc ->
+      bind(acc, func)
+    end)
+  end
+end
+```
+
+## 4. テスタビリティ
+
+### 依存性注入
+
+```elixir
+# HTTPクライアントを注入可能に
+def fetch_user(user_id, http_client \\ &default_http_client/1) do
+  case http_client.("https://api.example.com/users/#{user_id}") do
+    {:ok, body} -> {:ok, parse_json(body)}
+    {:error, _} = error -> error
+  end
+end
+
+# 時計を注入可能に
+def is_weekend?(clock \\ &DateTime.utc_now/0) do
+  day = clock.() |> Date.day_of_week()
+  day in [6, 7]
+end
+
+# テストでの使用
+test "is_weekend? with mock clock" do
+  saturday = fn -> ~D[2024-01-06] end
+  assert is_weekend?(saturday)
+end
+```
+
+### プロパティベーステスト向けの設計
+
+```elixir
+# 逆演算が存在する関数
+def encode(string), do: Base.encode64(string)
+def decode(encoded), do: Base.decode64!(encoded)
+
+# 冪等な関数
+def normalize_email(email) do
+  email |> String.downcase() |> String.trim()
+end
+```
+
+## 5. パフォーマンス最適化
+
+### 遅延評価
+
+```elixir
+# 大きなデータセットにはStreamを使用
+def process_large_file(path) do
+  File.stream!(path)
+  |> Stream.map(&String.trim/1)
+  |> Stream.filter(&(String.length(&1) > 0))
+  |> Enum.take(100)
+end
+
+# 無限ストリーム
+def fibonacci_stream do
+  Stream.unfold({0, 1}, fn {a, b} -> {a, {b, a + b}} end)
+end
+```
+
+### 末尾再帰
+
+```elixir
+# ❌ 末尾再帰でない
+def sum_bad([]), do: 0
+def sum_bad([h | t]), do: h + sum_bad(t)
+
+# ✅ 末尾再帰
+def sum_good(list), do: do_sum(list, 0)
+defp do_sum([], acc), do: acc
+defp do_sum([h | t], acc), do: do_sum(t, acc + h)
+```
+
+### データ構造の選択
+
+```elixir
+# O(1)のメンバーシップ検査にはMapSetを使用
+def member_check_efficient(items, item) do
+  set = MapSet.new(items)
+  MapSet.member?(set, item)
+end
+
+# キーによる高速ルックアップにはMapを使用
+def build_index(items, key_fn) do
+  Map.new(items, fn item -> {key_fn.(item), item} end)
+end
+```
+
+## 6. コード構成
+
+### 小さな関数
+
+```elixir
+def validate_email(email) do
+  email
+  |> check_format()
+  |> check_domain()
+  |> check_length()
+end
+
+defp check_format({:error, _} = error), do: error
+defp check_format(email) do
+  if String.match?(email, ~r/^[\w.+-]+@[\w.-]+\.\w+$/) do
+    email
+  else
+    {:error, :invalid_format}
+  end
+end
+```
+
+### モジュールの責務分離
+
+```elixir
+# データ定義
+defmodule User do
+  defstruct [:id, :name, :email, :role]
+end
+
+# ビジネスロジック
+defmodule UserService do
+  def can_access?(user, resource) do
+    user.role in allowed_roles(resource)
+  end
+end
+
+# フォーマット
+defmodule UserFormatter do
+  def to_display_name(%User{name: name}), do: name
+end
+```
+
+## 7. 実践的なパターン
+
+### オプションパターン
+
+```elixir
+@default_options [timeout: 5000, retries: 3]
+
+def fetch_data(url, opts \\ []) do
+  opts = Keyword.merge(@default_options, opts)
+  # ...
+end
+```
+
+### ビルダーパターン
+
+```elixir
+defmodule Builder do
+  defstruct fields: %{}, validations: []
+
+  def new, do: %__MODULE__{}
+  def set(b, key, value), do: %{b | fields: Map.put(b.fields, key, value)}
+  def build(b), do: {:ok, b.fields}
+end
+```
+
+### メモ化
+
+```elixir
+defmodule Memoization do
+  use Agent
+
+  def memoize(key, func) do
+    case Agent.get(__MODULE__, &Map.get(&1, key)) do
+      nil ->
+        result = func.()
+        Agent.update(__MODULE__, &Map.put(&1, key, result))
+        result
+      cached ->
+        cached
+    end
+  end
+end
+```
+
+## まとめ
+
+| ベストプラクティス | 目的 |
+|------------------|------|
+| 純粋関数 | テスタビリティ、予測可能性 |
+| パイプライン | 可読性、データフロー明確化 |
+| タグ付きタプル | 明示的なエラーハンドリング |
+| 依存性注入 | テスト容易性 |
+| 遅延評価 | パフォーマンス |
+| 末尾再帰 | メモリ効率 |
+| 小さな関数 | 保守性、再利用性 |
+
+これらのプラクティスを意識することで、より堅牢で保守しやすい Elixir コードが書けます。