@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/elixir/03-polymorphism.md

@@ -0,0 +1,375 @@
+# 第3章: 多態性の実現方法
+
+## はじめに
+
+多態性（ポリモーフィズム）は、同じインターフェースで異なる振る舞いを実現する強力な概念です。Elixir では、パターンマッチング、プロトコル、ビヘイビアという複数のメカニズムで多態性を実現します。
+
+本章では、これらのメカニズムを使い分けて、柔軟で拡張性の高いコードを書く方法を学びます。
+
+## 1. パターンマッチングによる多態性
+
+Elixir ではタグ付きタプルと関数のパターンマッチングを使って、代数的データ型（ADT）に相当する設計を実現できます。
+
+### 基本的な使い方
+
+```elixir
+# 図形をタグ付きタプルで表現
+@type shape ::
+  {:rectangle, width :: number(), height :: number()}
+  | {:circle, radius :: number()}
+  | {:triangle, base :: number(), height :: number()}
+
+# 図形の面積を計算する
+def calculate_area({:rectangle, width, height}), do: width * height
+def calculate_area({:circle, radius}), do: :math.pi() * radius * radius
+def calculate_area({:triangle, base, height}), do: base * height / 2
+
+# 使用例
+calculate_area({:rectangle, 4, 5})  # => 20
+calculate_area({:circle, 3})        # => 28.27...
+calculate_area({:triangle, 6, 5})   # => 15.0
+```
+
+### 構造体を使った多態性
+
+```elixir
+defmodule Rectangle do
+  defstruct [:width, :height]
+end
+
+defmodule Circle do
+  defstruct [:radius]
+end
+
+defmodule Triangle do
+  defstruct [:base, :height]
+end
+
+def area(%Rectangle{width: w, height: h}), do: w * h
+def area(%Circle{radius: r}), do: :math.pi() * r * r
+def area(%Triangle{base: b, height: h}), do: b * h / 2
+
+# 使用例
+area(%Rectangle{width: 4, height: 5})  # => 20
+area(%Circle{radius: 3})               # => 28.27...
+```
+
+## 2. 複合ディスパッチ
+
+タプルを使ったパターンマッチングで、複数の値に基づくディスパッチを実現できます。
+
+```elixir
+defmodule Payment do
+  defstruct [:method, :currency, :amount]
+end
+
+defmodule PaymentResult do
+  defstruct [:status, :message, :amount, :converted]
+end
+
+def process_payment(%Payment{method: method, currency: currency, amount: amount}) do
+  case {method, currency} do
+    {:credit_card, :jpy} ->
+      %PaymentResult{
+        status: "processed",
+        message: "クレジットカード（円）で処理しました",
+        amount: amount
+      }
+
+    {:credit_card, :usd} ->
+      %PaymentResult{
+        status: "processed",
+        message: "Credit card (USD) processed",
+        amount: amount,
+        converted: amount * 150
+      }
+
+    {:bank_transfer, :jpy} ->
+      %PaymentResult{
+        status: "pending",
+        message: "銀行振込を受け付けました",
+        amount: amount
+      }
+
+    _ ->
+      %PaymentResult{
+        status: "error",
+        message: "サポートされていない支払い方法です",
+        amount: amount
+      }
+  end
+end
+
+# 使用例
+process_payment(%Payment{method: :credit_card, currency: :jpy, amount: 1000})
+# => %PaymentResult{status: "processed", message: "クレジットカード（円）で処理しました", ...}
+```
+
+## 3. プロトコルによる多態性
+
+プロトコルは、特定の操作セットを定義するインターフェースです。異なる型に対して同じ関数を呼び出せるようになります。
+
+### プロトコルの定義と実装
+
+```elixir
+defprotocol Describable do
+  @doc "オブジェクトの説明を返す"
+  @spec describe(t) :: String.t()
+  def describe(value)
+end
+
+defmodule Product do
+  defstruct [:name, :price]
+end
+
+defmodule Service do
+  defstruct [:name, :hourly_rate]
+end
+
+defimpl Describable, for: Product do
+  def describe(%Product{name: name, price: price}) do
+    "商品: #{name} (#{price}円)"
+  end
+end
+
+defimpl Describable, for: Service do
+  def describe(%Service{name: name, hourly_rate: rate}) do
+    "サービス: #{name} (時給#{rate}円)"
+  end
+end
+
+# 組み込み型にも実装できる
+defimpl Describable, for: Map do
+  def describe(map) do
+    "マップ with #{map_size(map)} keys"
+  end
+end
+
+defimpl Describable, for: List do
+  def describe(list) do
+    "リスト with #{length(list)} elements"
+  end
+end
+
+# 使用例
+Describable.describe(%Product{name: "りんご", price: 150})
+# => "商品: りんご (150円)"
+
+Describable.describe(%{a: 1, b: 2, c: 3})
+# => "マップ with 3 keys"
+```
+
+### プロトコルの利点
+
+1. **拡張性**: 既存の型に対して後から振る舞いを追加可能
+2. **分離**: 型定義とプロトコル実装を別ファイルに分離可能
+3. **多態性**: 異なる型に対して統一的なインターフェースを提供
+
+## 4. ビヘイビアによる多態性
+
+ビヘイビアは、モジュールが実装すべきコールバック関数を定義します。Java のインターフェースに似ています。
+
+```elixir
+defmodule Serializer do
+  @callback serialize(data :: any()) :: String.t()
+  @callback deserialize(string :: String.t()) :: any()
+end
+
+defmodule JsonSerializer do
+  @behaviour Serializer
+
+  @impl Serializer
+  def serialize(data) do
+    # JSON シリアライズ実装
+    inspect(data)
+  end
+
+  @impl Serializer
+  def deserialize(_string) do
+    %{}
+  end
+end
+
+defmodule CsvSerializer do
+  @behaviour Serializer
+
+  @impl Serializer
+  def serialize(data) when is_list(data) do
+    data
+    |> Enum.map(&Enum.join(&1, ","))
+    |> Enum.join("\n")
+  end
+
+  def serialize(_), do: ""
+
+  @impl Serializer
+  def deserialize(string) do
+    string
+    |> String.split("\n")
+    |> Enum.map(&String.split(&1, ","))
+  end
+end
+
+# 使用例
+CsvSerializer.serialize([["a", "b", "c"], ["1", "2", "3"]])
+# => "a,b,c\n1,2,3"
+```
+
+### ビヘイビアとプロトコルの使い分け
+
+| 特性 | プロトコル | ビヘイビア |
+|-----|-----------|-----------|
+| ディスパッチ | データの型による | モジュールによる |
+| 用途 | 異なる型に同じ操作 | 交換可能な実装 |
+| 例 | `Enumerable`, `String.Chars` | `GenServer`, `Supervisor` |
+
+## 5. 型クラス相当（プロトコル + 実装）
+
+プロトコルを使って、関数型言語の型クラスに相当するパターンを実現できます。
+
+```elixir
+defprotocol Monoid do
+  @doc "結合演算"
+  @spec combine(t, t) :: t
+  def combine(a, b)
+end
+
+defmodule Sum do
+  defstruct [:value]
+  def empty, do: %Sum{value: 0}
+end
+
+defmodule Multiply do
+  defstruct [:value]
+  def empty, do: %Multiply{value: 1}
+end
+
+defimpl Monoid, for: Sum do
+  def combine(%Sum{value: a}, %Sum{value: b}), do: %Sum{value: a + b}
+end
+
+defimpl Monoid, for: Multiply do
+  def combine(%Multiply{value: a}, %Multiply{value: b}), do: %Multiply{value: a * b}
+end
+
+defimpl Monoid, for: List do
+  def combine(a, b), do: a ++ b
+end
+
+# モノイドのリストを畳み込む
+def fold_monoid(list, empty) do
+  Enum.reduce(list, empty, &Monoid.combine(&2, &1))
+end
+
+# 使用例
+sums = [%Sum{value: 1}, %Sum{value: 2}, %Sum{value: 3}]
+fold_monoid(sums, Sum.empty())
+# => %Sum{value: 6}
+```
+
+## 6. 動的ディスパッチ
+
+マップを使った関数のディスパッチで、実行時に柔軟な振る舞いの切り替えができます。
+
+```elixir
+def dispatch(handlers, operation, args) do
+  case Map.get(handlers, operation) do
+    nil -> raise ArgumentError, "Unknown operation: #{operation}"
+    handler -> apply(handler, args)
+  end
+end
+
+def create_calculator do
+  handlers = %{
+    add: fn a, b -> a + b end,
+    subtract: fn a, b -> a - b end,
+    multiply: fn a, b -> a * b end,
+    divide: fn a, b -> a / b end
+  }
+
+  fn operation, a, b ->
+    dispatch(handlers, operation, [a, b])
+  end
+end
+
+# 使用例
+calc = create_calculator()
+calc.(:add, 5, 3)       # => 8
+calc.(:divide, 10, 2)   # => 5.0
+```
+
+## 7. 式の評価（再帰的なパターンマッチング）
+
+パターンマッチングを使った再帰的なデータ構造の処理は、Elixir の得意分野です。
+
+```elixir
+@type expr ::
+  {:num, number()}
+  | {:add, expr(), expr()}
+  | {:sub, expr(), expr()}
+  | {:mul, expr(), expr()}
+  | {:div, expr(), expr()}
+
+def evaluate({:num, n}), do: n
+def evaluate({:add, left, right}), do: evaluate(left) + evaluate(right)
+def evaluate({:sub, left, right}), do: evaluate(left) - evaluate(right)
+def evaluate({:mul, left, right}), do: evaluate(left) * evaluate(right)
+def evaluate({:div, left, right}), do: evaluate(left) / evaluate(right)
+
+def expr_to_string({:num, n}), do: to_string(n)
+def expr_to_string({:add, left, right}) do
+  "(#{expr_to_string(left)} + #{expr_to_string(right)})"
+end
+# ... 他の演算子も同様
+
+# 使用例
+expr = {:add, {:num, 5}, {:mul, {:num, 2}, {:num, 3}}}
+evaluate(expr)          # => 11
+expr_to_string(expr)    # => "(5 + (2 * 3))"
+```
+
+## 8. ガード節による多態性
+
+ガード節を使うと、型や値の条件に基づいて関数をディスパッチできます。
+
+```elixir
+def describe_value(n) when is_integer(n) and n > 0, do: "正の整数: #{n}"
+def describe_value(n) when is_integer(n) and n < 0, do: "負の整数: #{n}"
+def describe_value(0), do: "ゼロ"
+def describe_value(n) when is_float(n), do: "浮動小数点数: #{n}"
+def describe_value(s) when is_binary(s), do: "文字列: #{s}"
+def describe_value(list) when is_list(list), do: "リスト（要素数: #{length(list)}）"
+def describe_value(map) when is_map(map), do: "マップ（キー数: #{map_size(map)}）"
+def describe_value(_), do: "その他"
+
+# 使用例
+describe_value(42)      # => "正の整数: 42"
+describe_value(-5)      # => "負の整数: -5"
+describe_value(3.14)    # => "浮動小数点数: 3.14"
+describe_value("hello") # => "文字列: hello"
+```
+
+## まとめ
+
+本章では、Elixir における多態性の実現方法について学びました：
+
+1. **パターンマッチング**: タグ付きタプルと関数のマルチヘッドによる ADT
+2. **構造体**: 明示的な型と構造体によるパターンマッチング
+3. **複合ディスパッチ**: 複数の値に基づく分岐
+4. **プロトコル**: 型に対する振る舞いの定義と実装
+5. **ビヘイビア**: モジュールレベルのインターフェース定義
+6. **動的ディスパッチ**: マップによる関数の実行時切り替え
+7. **ガード節**: 型や値の条件による分岐
+
+これらのメカニズムを適切に使い分けることで、柔軟で保守しやすいコードを書くことができます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/elixir/part1/lib/chapter03.ex`
+- テストコード: `apps/elixir/part1/test/chapter03_test.exs`
+
+## 次章予告
+
+次章では、**データ検証**について学びます。Elixir での型チェックとバリデーションパターンを探ります。

package/lib/assets/docs/article/functional-desgin-ppp/elixir/04-data-validation.md

@@ -0,0 +1,195 @@
+# Chapter 04: データバリデーション
+
+Elixir におけるデータバリデーションと型安全性について学びます。
+
+## 概要
+
+このチャプターでは、関数型プログラミングにおけるデータバリデーションのパターンを紹介します。
+Elixir の Result 型（`{:ok, value} | {:error, reason}`）と Validated パターンを使って、
+安全で表現力豊かなバリデーションを実装します。
+
+## 主なトピック
+
+1. **Result 型によるエラーハンドリング**
+2. **バリデータの合成**
+3. **スマートコンストラクタ**
+4. **エラーの蓄積**
+5. **値オブジェクト**
+
+## Result 型とは
+
+Result 型は、成功と失敗を明示的に表現するデータ構造です。
+
+```elixir
+@type result(a) :: {:ok, a} | {:error, String.t()}
+```
+
+例外をスローする代わりに、失敗を通常の戻り値として扱います。
+
+## 実装例
+
+### 基本的なバリデータ
+
+```elixir
+defmodule Chapter04 do
+  @doc """
+  正の数であることを検証する。
+  """
+  @spec validate_positive(number()) :: {:ok, number()} | {:error, String.t()}
+  def validate_positive(n) when n > 0, do: {:ok, n}
+  def validate_positive(_), do: {:error, "正の数が必要です"}
+  
+  @doc """
+  空でない文字列であることを検証する。
+  """
+  @spec validate_non_empty(String.t()) :: {:ok, String.t()} | {:error, String.t()}
+  def validate_non_empty(""), do: {:error, "空文字列は許可されません"}
+  def validate_non_empty(s) when is_binary(s), do: {:ok, s}
+end
+```
+
+### バリデータの合成
+
+複数のバリデータを組み合わせて、複雑な検証ロジックを構築します。
+
+```elixir
+# 最初のエラーで停止
+def validate_all(value, validators) do
+  Enum.reduce_while(validators, {:ok, value}, fn v, {:ok, val} ->
+    case v.(val) do
+      {:ok, _} = result -> {:cont, result}
+      {:error, _} = error -> {:halt, error}
+    end
+  end)
+end
+
+# すべてのエラーを蓄積
+def validate_all_accumulate(value, validators) do
+  errors =
+    validators
+    |> Enum.map(fn v -> v.(value) end)
+    |> Enum.flat_map(fn
+      {:error, e} -> e
+      {:ok, _} -> []
+    end)
+
+  if errors == [], do: {:valid, value}, else: {:invalid, errors}
+end
+```
+
+### スマートコンストラクタ
+
+不正な値を作成できないように、検証付きコンストラクタを提供します。
+
+```elixir
+defmodule Email do
+  @enforce_keys [:value]
+  defstruct [:value]
+
+  @spec new(String.t()) :: {:ok, t()} | {:error, String.t()}
+  def new(email) do
+    cond do
+      not String.contains?(email, "@") ->
+        {:error, "メールアドレスには @ が必要です"}
+      String.length(email) < 5 ->
+        {:error, "メールアドレスが短すぎます"}
+      true ->
+        {:ok, %__MODULE__{value: email}}
+    end
+  end
+end
+```
+
+## with 式によるバリデーション
+
+Elixir の `with` 式を使うと、複数のバリデーションを順次実行できます。
+
+```elixir
+def validate_user(name, age, email) do
+  with {:ok, valid_name} <- NonEmptyString.new(name),
+       {:ok, valid_age} <- PositiveInteger.new(age),
+       {:ok, valid_email} <- Email.new(email) do
+    {:ok, %{name: valid_name, age: valid_age, email: valid_email}}
+  end
+end
+```
+
+`with` 式は最初の失敗で停止し、エラーを返します。
+
+## Validated パターン
+
+すべてのエラーを蓄積したい場合は、Validated パターンを使います。
+
+```elixir
+@type validated(a) :: {:valid, a} | {:invalid, [String.t()]}
+
+def validate_user_accumulate(params) do
+  results = [
+    validate_field(params, :name, &NonEmptyString.new/1),
+    validate_field(params, :age, &PositiveInteger.new/1),
+    validate_field(params, :email, &Email.new/1)
+  ]
+  
+  errors = Enum.flat_map(results, fn
+    {:error, e} -> [e]
+    {:ok, _} -> []
+  end)
+  
+  if errors == [] do
+    {:valid, build_user(results)}
+  else
+    {:invalid, errors}
+  end
+end
+```
+
+## テスト例
+
+```elixir
+defmodule Chapter04Test do
+  use ExUnit.Case
+
+  describe "Email.new/1" do
+    test "有効なメールアドレスで作成できる" do
+      assert {:ok, %Email{value: "test@example.com"}} = Email.new("test@example.com")
+    end
+
+    test "@ がないとエラー" do
+      assert {:error, _} = Email.new("invalid")
+    end
+  end
+
+  describe "validate_all/2" do
+    test "すべてのバリデータが成功すると :ok" do
+      validators = [
+        fn x -> if x > 0, do: {:ok, x}, else: {:error, "正の数が必要"} end,
+        fn x -> if x < 100, do: {:ok, x}, else: {:error, "100未満が必要"} end
+      ]
+      
+      assert {:ok, 50} = Chapter04.validate_all(50, validators)
+    end
+
+    test "最初のエラーで停止する" do
+      validators = [
+        fn _ -> {:error, "エラー1"} end,
+        fn _ -> {:error, "エラー2"} end
+      ]
+      
+      assert {:error, ["エラー1"]} = Chapter04.validate_all(0, validators)
+    end
+  end
+end
+```
+
+## まとめ
+
+- **Result 型**で成功と失敗を明示的に表現
+- **バリデータの合成**で複雑な検証ロジックを構築
+- **スマートコンストラクタ**で不正な値の作成を防止
+- **with 式**で逐次的なバリデーション
+- **Validated パターン**ですべてのエラーを蓄積
+
+## 関連リソース
+
+- [Elixir ドキュメント: with](https://hexdocs.pm/elixir/Kernel.SpecialForms.html#with/1)
+- [Railway Oriented Programming](https://fsharpforfunandprofit.com/rop/)