@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,300 @@
+# 第4章: データ検証 — 6言語統合ガイド
+
+## 1. はじめに
+
+データ検証は、ソフトウェアの信頼性を支える基礎です。不正なデータがシステムの奥深くまで浸透すると、デバッグが困難なバグを引き起こします。関数型プログラミングでは、**型レベルの保証**と**ランタイム検証**を組み合わせ、「不正な状態を表現不可能にする」ことを目指します。
+
+本章では、各言語のバリデーション戦略を**静的検証（コンパイル時）**と**動的検証（実行時）**の軸で比較します。
+
+## 2. 共通の本質
+
+### バリデーション結果の表現
+
+すべての言語が共通して持つ 2 つのパターン：
+
+1. **逐次検証（Fail-Fast）**: 最初のエラーで停止し、そのエラーを返す
+2. **蓄積検証（Error Accumulation）**: すべての検証を実行し、エラーをまとめて返す
+
+```
+逐次検証:  validate(a) → validate(b) → validate(c)  ※ 最初の失敗で停止
+蓄積検証:  validate(a) ⊕ validate(b) ⊕ validate(c)  ※ すべて実行してエラーを収集
+```
+
+### ドメインプリミティブ
+
+「生の値」ではなく「検証済みの値」を型で表現するパターンです。スマートコンストラクタを通じてのみ値を生成し、不正な状態を構造的に排除します。
+
+## 3. 言語別実装比較
+
+### 3.1 バリデーション結果の型表現
+
+| 言語 | 逐次検証 | 蓄積検証 | ドメインプリミティブ |
+|------|---------|---------|------------------|
+| Clojure | `s/valid?` + `s/explain` | Spec による自動検証 | Spec + スマートコンストラクタ |
+| Scala | `Either[List[String], A]` | `Validated` パターン | Opaque Type |
+| Elixir | `:ok` / `:error` タプル | `with` 式チェーン | 構造体 + スマートコンストラクタ |
+| F# | `Result<'T, 'E>` | `Validated` 型 | プライベートコンストラクタ |
+| Haskell | `Either ValidationError a` | `Validated` 型 | `newtype` |
+| Rust | `Result<T, E>` | `Validated<E, A>` 型 | struct + private フィールド |
+
+### 3.2 Clojure Spec — ランタイム仕様定義
+
+Clojure は他の言語とは根本的に異なるアプローチを取ります。`clojure.spec` は**ランタイム仕様定義システム**であり、バリデーション・テストデータ生成・ドキュメンテーションを統合的に提供します。
+
+```clojure
+(require '[clojure.spec.alpha :as s])
+
+;; スペック定義
+(s/def ::name (s/and string? #(>= (count %) 1)))
+(s/def ::age (s/and int? #(>= % 0) #(<= % 150)))
+(s/def ::email (s/and string? #(re-matches #".+@.+\..+" %)))
+
+;; 複合スペック
+(s/def ::person (s/keys :req-un [::name ::age ::email]))
+
+;; 検証
+(s/valid? ::person {:name "田中" :age 30 :email "tanaka@example.com"})
+;; => true
+
+;; エラー詳細
+(s/explain ::person {:name "" :age -1 :email "invalid"})
+;; => 全エラーを一覧表示
+```
+
+Spec の特筆すべき点は、仕様定義からテストデータを**自動生成**できることです：
+
+```clojure
+(require '[clojure.spec.gen.alpha :as gen])
+(gen/sample (s/gen ::person) 3)
+;; => ({:name "a" :age 42 :email "x@y.z"} ...)
+```
+
+### 3.3 静的型付け言語の型レベル検証
+
+<details>
+<summary>Scala: Either + Validated + Opaque Type</summary>
+
+```scala
+// 逐次検証（Either）
+type ValidationResult[A] = Either[List[String], A]
+
+def validateName(name: String): ValidationResult[String] =
+  if name.nonEmpty then Right(name)
+  else Left(List("名前は必須です"))
+
+// 蓄積検証（Validated）
+case class Validated[+E, +A](value: Either[List[E], A])
+
+object Validated:
+  def valid[E, A](a: A): Validated[E, A] = Validated(Right(a))
+  def invalid[E, A](e: E): Validated[E, A] = Validated(Left(List(e)))
+
+  def combine[E, A, B, C](va: Validated[E, A], vb: Validated[E, B])
+    (f: (A, B) => C): Validated[E, C] = (va.value, vb.value) match
+      case (Right(a), Right(b)) => valid(f(a, b))
+      case (Left(e1), Left(e2)) => Validated(Left(e1 ++ e2))
+      case (Left(e), _) => Validated(Left(e))
+      case (_, Left(e)) => Validated(Left(e))
+
+// ドメインプリミティブ（Opaque Type）
+opaque type ProductId = String
+object ProductId:
+  def apply(value: String): Either[String, ProductId] =
+    if value.matches("^[A-Z]{2}-\\d{4}$") then Right(value)
+    else Left("商品IDの形式が不正です")
+```
+
+</details>
+
+<details>
+<summary>F#: Result + Validated + パイプライン</summary>
+
+```fsharp
+// 逐次検証（Result）
+let validateName (name: string) =
+    if String.IsNullOrWhiteSpace name then Error "名前は必須です"
+    else Ok name
+
+// 蓄積検証（Validated）
+type Validated<'E, 'A> =
+    | Valid of 'A
+    | Invalid of 'E list
+
+module Validated =
+    let combine f va vb =
+        match va, vb with
+        | Valid a, Valid b -> Valid (f a b)
+        | Invalid e1, Invalid e2 -> Invalid (e1 @ e2)
+        | Invalid e, _ | _, Invalid e -> Invalid e
+
+// パイプラインによる検証チェーン
+let validatePerson name age email =
+    validateName name
+    |> Result.bind (fun n ->
+        validateAge age
+        |> Result.map (fun a -> (n, a)))
+    |> Result.bind (fun (n, a) ->
+        validateEmail email
+        |> Result.map (fun e -> { Name = n; Age = a; Email = e }))
+```
+
+</details>
+
+<details>
+<summary>Haskell: Either + Validated + newtype</summary>
+
+```haskell
+-- 逐次検証（Either）
+validateName :: String -> Either ValidationError String
+validateName name
+    | null name = Left (ValidationError "名前は必須です")
+    | otherwise = Right name
+
+-- 蓄積検証（Validated）
+data Validated a = Valid a | Invalid [ValidationError]
+
+combineValidated :: Validated a -> Validated b -> (a -> b -> c) -> Validated c
+combineValidated (Valid a) (Valid b) f = Valid (f a b)
+combineValidated (Invalid e1) (Invalid e2) _ = Invalid (e1 ++ e2)
+combineValidated (Invalid e) _ _ = Invalid e
+combineValidated _ (Invalid e) _ = Invalid e
+
+-- ドメインプリミティブ（newtype）
+newtype Email = Email String
+
+mkEmail :: String -> Either ValidationError Email
+mkEmail s
+    | isValidEmail s = Right (Email s)
+    | otherwise = Left (ValidationError "無効なメールアドレス")
+```
+
+Haskell の `newtype` はコンパイル時に除去されるため、**ゼロコスト**で型安全性を追加できます。
+
+</details>
+
+<details>
+<summary>Rust: Result + Validated + Newtype</summary>
+
+```rust
+// 逐次検証（Result）
+pub fn validate_name(name: &str) -> Result<String, String> {
+    if name.is_empty() {
+        Err("名前は必須です".to_string())
+    } else {
+        Ok(name.to_string())
+    }
+}
+
+// ドメインプリミティブ（Newtype パターン）
+pub struct ProductId(String);
+
+impl ProductId {
+    pub fn new(value: &str) -> Result<Self, String> {
+        if value.len() >= 3 && value.starts_with("P-") {
+            Ok(ProductId(value.to_string()))
+        } else {
+            Err("商品IDの形式が不正です".to_string())
+        }
+    }
+
+    pub fn value(&self) -> &str { &self.0 }
+}
+```
+
+</details>
+
+<details>
+<summary>Elixir: :ok/:error タプル + with 式</summary>
+
+```elixir
+def validate_name(name) when is_binary(name) and byte_size(name) > 0 do
+  {:ok, name}
+end
+def validate_name(_), do: {:error, "名前は必須です"}
+
+# with 式による逐次検証（Railway Oriented Programming）
+def validate_person(params) do
+  with {:ok, name} <- validate_name(params.name),
+       {:ok, age} <- validate_age(params.age),
+       {:ok, email} <- validate_email(params.email) do
+    {:ok, %Person{name: name, age: age, email: email}}
+  end
+end
+```
+
+Elixir の `with` 式は、エラーが発生した時点で自動的にそのエラーを返す**Railway Oriented Programming**を簡潔に表現します。
+
+</details>
+
+### 3.4 ドメインプリミティブの実装コスト
+
+| 言語 | 実装方法 | ランタイムコスト | コンパイル時保証 |
+|------|---------|----------------|----------------|
+| Clojure | Spec + スマートコンストラクタ | 実行時検証のみ | なし |
+| Scala | Opaque Type | ゼロ | 完全 |
+| Elixir | 構造体 + コンストラクタ | 実行時検証のみ | なし |
+| F# | プライベートコンストラクタ | ゼロ | 完全 |
+| Haskell | `newtype` | ゼロ（コンパイル時除去） | 完全 |
+| Rust | struct + private フィールド | ゼロ | 完全 |
+
+## 4. 比較分析
+
+### 4.1 検証スペクトラム
+
+```
+    コンパイル時 ←――――――――――――――――→ 実行時
+
+    Haskell    F#    Rust    Scala    Elixir    Clojure
+    ├─型クラス──┤     │       │        │         │
+               ├─DU──┤       │        │         │
+                     ├─enum──┤        │         │
+                             ├─trait──┤         │
+                                      ├─with 式─┤
+                                                ├─Spec
+```
+
+静的型付け言語はコンパイル時に多くの不正状態を排除できます。動的型付け言語はテストとランタイム検証で同等の安全性を確保します。
+
+### 4.2 エラー蓄積戦略
+
+逐次検証と蓄積検証の使い分け：
+
+| 戦略 | ユースケース | 実装する言語 |
+|------|-----------|------------|
+| 逐次検証（Fail-Fast） | 依存関係のある検証（ID 存在確認 → 権限チェック） | 全 6 言語 |
+| 蓄積検証（Error Accumulation） | フォーム入力の一括検証 | Scala, F#, Haskell, Rust, Clojure |
+
+Elixir は `with` 式が逐次検証に特化しており、蓄積検証を行うには独自の実装が必要です。
+
+### 4.3 Clojure Spec の独自性
+
+Clojure Spec は他の言語のバリデーションライブラリとは根本的に異なります：
+
+| 機能 | Clojure Spec | 他言語の型システム |
+|------|-------------|----------------|
+| バリデーション | ランタイム | コンパイル時 |
+| テストデータ生成 | 仕様から自動生成 | 別ライブラリが必要 |
+| ドキュメンテーション | 仕様が文書を兼ねる | 型注釈が文書を兼ねる |
+| 合成可能性 | `s/and`, `s/or` で自由に合成 | 型演算子で合成 |
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| コンパイル時の最大保証 | Haskell | `newtype` + 型クラスで不正状態を型レベルで排除 |
+| バリデーションとテスト統合 | Clojure | Spec が検証・生成・文書を一体化 |
+| 実務的なバランス | F#, Rust | 型安全性 + 実用的なエラーハンドリング |
+| Web フォーム検証 | Elixir | `with` 式 + Ecto changeset との統合 |
+| DSL 的な表現力 | Scala | Opaque Type + 流暢な API |
+
+## 6. まとめ
+
+データ検証は、関数型プログラミングにおける**正しさの保証**の出発点です：
+
+1. **型レベル vs ランタイム**: 静的型付け言語はコンパイル時に、動的型付け言語はテストとランタイムで保証
+2. **ドメインプリミティブ**: すべての言語で「生の値を型で包む」パターンが有効
+3. **エラー蓄積**: 逐次検証と蓄積検証を使い分けることで、ユーザーフレンドリーな検証を実現
+
+## 言語別個別記事
+
+- [Clojure](../clojure/04-clojure-spec.md) | [Scala](../scala/04-data-validation.md) | [Elixir](../elixir/04-data-validation.md) | [F#](../fsharp/04-data-validation.md) | [Haskell](../haskell/04-data-validation.md) | [Rust](../rust/04-data-validation.md)

package/lib/assets/docs/article/functional-desgin-ppp/all/05-property-based-testing.md

@@ -0,0 +1,320 @@
+# 第5章: プロパティベーステスト — 6言語統合ガイド
+
+## 1. はじめに
+
+従来の Example-Based Testing は「特定の入力に対する特定の出力」を検証しますが、**プロパティベーステスト（PBT）**は「すべての入力に対して成り立つ性質」を検証します。テストデータを自動生成し、数百〜数千のランダムケースで性質を検証することで、開発者が思いつかないエッジケースを発見できます。
+
+## 2. 共通の本質
+
+### PBT の基本構造
+
+```
+1. 性質（Property）を定義する
+2. テストデータをランダムに生成する（Generator）
+3. 性質が成り立つか検証する
+4. 失敗時、最小の反例を見つける（Shrinking）
+```
+
+### 代表的な性質パターン
+
+| パターン | 定義 | 例 |
+|---------|------|-----|
+| 冪等性（Idempotency） | `f(f(x)) = f(x)` | sort のソート済み再ソート |
+| 対合性（Involution） | `f(f(x)) = x` | reverse の二重適用 |
+| 不変量（Invariant） | 操作前後で保存される性質 | ソート後も要素数は同じ |
+| 往復（Round-trip） | `decode(encode(x)) = x` | シリアライズの往復 |
+| モデルベース | 別の実装と同じ結果 | 自作 sort と標準 sort の比較 |
+
+## 3. 言語別実装比較
+
+### 3.1 PBT ライブラリ
+
+| 言語 | ライブラリ | 特徴 |
+|------|----------|------|
+| Clojure | test.check | Spec との統合、ジェネレータが豊富 |
+| Scala | ScalaCheck | 型クラスベース、ScalaTest 統合 |
+| Elixir | StreamData | Stream ベースの遅延生成 |
+| F# | FsCheck | 属性ベース、`[<Property>]` で宣言的 |
+| Haskell | QuickCheck | PBT の元祖、条件付きプロパティ |
+| Rust | proptest | マクロベース、Strategy trait で拡張 |
+
+### 3.2 冪等性の検証
+
+「同じ操作を 2 回適用しても結果が変わらない」性質です。
+
+<details>
+<summary>Clojure: test.check</summary>
+
+```clojure
+(require '[clojure.test.check :as tc]
+         '[clojure.test.check.generators :as gen]
+         '[clojure.test.check.properties :as prop])
+
+(def prop-sort-idempotent
+  (prop/for-all [nums (gen/vector gen/small-integer)]
+    (= (sort nums) (sort (sort nums)))))
+
+(tc/quick-check 100 prop-sort-idempotent)
+```
+
+</details>
+
+<details>
+<summary>Scala: ScalaCheck</summary>
+
+```scala
+import org.scalacheck.Prop.forAll
+
+test("ソートは冪等である") {
+  forAll { (nums: List[Int]) =>
+    val sorted = nums.sorted
+    sorted shouldBe sorted.sorted
+  }
+}
+```
+
+</details>
+
+<details>
+<summary>Haskell: QuickCheck</summary>
+
+```haskell
+import Test.QuickCheck
+
+prop_sortIdempotent :: [Int] -> Bool
+prop_sortIdempotent xs = sort (sort xs) == sort xs
+
+-- 実行
+-- quickCheck prop_sortIdempotent
+```
+
+</details>
+
+<details>
+<summary>Rust: proptest</summary>
+
+```rust
+use proptest::prelude::*;
+
+proptest! {
+    #[test]
+    fn sort_is_idempotent(mut xs: Vec<i32>) {
+        xs.sort();
+        let sorted_once = xs.clone();
+        xs.sort();
+        prop_assert_eq!(xs, sorted_once);
+    }
+}
+```
+
+</details>
+
+<details>
+<summary>F#: FsCheck</summary>
+
+```fsharp
+[<Property>]
+let ``ソートは冪等である`` (nums: int list) =
+    let sorted = List.sort nums
+    sorted = List.sort sorted
+```
+
+F# の FsCheck は `[<Property>]` 属性をつけるだけでプロパティテストを宣言できます。
+
+</details>
+
+<details>
+<summary>Elixir: StreamData</summary>
+
+```elixir
+property "ソートは冪等である" do
+  check all nums <- list_of(integer()) do
+    sorted = Enum.sort(nums)
+    assert sorted == Enum.sort(sorted)
+  end
+end
+```
+
+</details>
+
+### 3.3 対合性と往復の検証
+
+<details>
+<summary>reverse の対合性（全言語比較）</summary>
+
+```clojure
+;; Clojure
+(def prop-reverse-involutory
+  (prop/for-all [xs (gen/vector gen/small-integer)]
+    (= xs (vec (reverse (reverse xs))))))
+```
+
+```scala
+// Scala
+forAll { (xs: List[Int]) =>
+  xs.reverse.reverse shouldBe xs
+}
+```
+
+```elixir
+# Elixir
+check all xs <- list_of(integer()) do
+  assert xs == xs |> Enum.reverse() |> Enum.reverse()
+end
+```
+
+```fsharp
+// F#
+[<Property>]
+let ``reverseの対合性`` (xs: int list) =
+    xs |> List.rev |> List.rev = xs
+```
+
+```haskell
+-- Haskell
+prop_reverseInvolutory :: [Int] -> Bool
+prop_reverseInvolutory xs = reverse (reverse xs) == xs
+```
+
+```rust
+// Rust
+proptest! {
+    #[test]
+    fn reverse_involutive(xs: Vec<i32>) {
+        let reversed: Vec<_> = xs.iter().rev().rev().cloned().collect();
+        prop_assert_eq!(&xs, &reversed);
+    }
+}
+```
+
+</details>
+
+### 3.4 ジェネレータの設計
+
+| ジェネレータ | Clojure | Scala | Elixir | F# | Haskell | Rust |
+|------------|---------|-------|--------|-----|---------|------|
+| 整数 | `gen/int` | `arbitrary[Int]` | `integer()` | 型推論 | `arbitrary` | 型推論 |
+| 文字列 | `gen/string` | `Gen.alphaStr` | `string(:alpha)` | 型推論 | `arbitrary` | 型推論 |
+| リスト | `gen/vector` | `Gen.listOf` | `list_of` | 型推論 | `listOf` | 型推論 |
+| カスタム型 | `gen/fmap` | `Gen.map` | `gen all` | 計算式 | `Gen` モナド | `Strategy` trait |
+| 範囲指定 | `gen/choose` | `Gen.choose` | `integer(1..100)` | `Gen.choose` | `choose` | `1..100i32` |
+
+<details>
+<summary>カスタムジェネレータの比較</summary>
+
+```clojure
+;; Clojure: gen/fmap で変換
+(def gen-person
+  (gen/fmap (fn [[name age]]
+              {:name name :age age})
+            (gen/tuple gen/string-alphanumeric
+                       (gen/choose 0 150))))
+```
+
+```scala
+// Scala: for 式で合成
+val genPerson: Gen[Person] = for
+  name <- Gen.alphaStr
+  age  <- Gen.choose(0, 150)
+yield Person(name, age)
+```
+
+```haskell
+-- Haskell: Gen モナドで合成
+genPerson :: Gen Person
+genPerson = do
+    name <- arbitrary
+    age  <- choose (0, 150)
+    return $ Person name age
+```
+
+```rust
+// Rust: Strategy trait で合成
+fn person_strategy() -> impl Strategy<Value = Person> {
+    ("[a-zA-Z]+", 0..150u32).prop_map(|(name, age)| {
+        Person { name, age }
+    })
+}
+```
+
+</details>
+
+### 3.5 シュリンキング（最小反例の発見）
+
+テストが失敗した場合、PBT ライブラリは自動的に入力を**縮小**し、最小の反例を見つけます。
+
+| 言語 | シュリンク方式 | 特徴 |
+|------|-------------|------|
+| Clojure | ジェネレータ統合 | ジェネレータが縮小方法も知っている |
+| Scala | `Shrink` 型クラス | カスタムシュリンク定義可能 |
+| Elixir | ジェネレータ統合 | StreamData が自動対応 |
+| F# | `Shrink` 型 | FsCheck が自動対応 |
+| Haskell | `Arbitrary` 型クラスの `shrink` | 最も細かく制御可能 |
+| Rust | ジェネレータ統合 | Strategy に組み込み |
+
+## 4. 比較分析
+
+### 4.1 PBT の表現力
+
+| 基準 | 最も表現力が高い言語 | 理由 |
+|------|-------------------|------|
+| ジェネレータ合成 | Haskell | モナド合成で自由に組み合わせ |
+| Spec 統合 | Clojure | 仕様定義からテストデータを自動生成 |
+| 宣言的記述 | F# | `[<Property>]` 属性で最も簡潔 |
+| マクロの活用 | Rust | `proptest!` マクロで定型コードを削減 |
+| テスト統合 | Scala | ScalaTest との seamless な統合 |
+| ストリーム生成 | Elixir | Stream ベースで遅延評価 |
+
+### 4.2 静的型付け vs 動的型付けの影響
+
+**静的型付け言語（Scala, F#, Haskell, Rust）**：
+
+- 型情報からジェネレータを**自動推論**できる
+- `arbitrary` を書くだけで適切なジェネレータが選択される
+- カスタム型のジェネレータも型クラスで定義可能
+
+**動的型付け言語（Clojure, Elixir）**：
+
+- ジェネレータを**明示的に指定**する必要がある
+- Clojure は Spec との統合でこの弱点を克服
+- より柔軟なジェネレータ合成が可能
+
+### 4.3 Clojure Spec と PBT の統合
+
+Clojure の最大の強みは、第 4 章で定義した Spec が PBT のジェネレータとして**直接再利用**できることです：
+
+```clojure
+;; 第4章で定義した Spec
+(s/def ::person (s/keys :req-un [::name ::age ::email]))
+
+;; そのまま PBT のジェネレータとして使用
+(def prop-person-roundtrip
+  (prop/for-all [person (s/gen ::person)]
+    (= person (deserialize (serialize person)))))
+```
+
+この統合は他の言語では実現できない、Clojure 固有の強みです。
+
+## 5. 実践的な選択指針
+
+| 要件 | 推奨言語 | 理由 |
+|------|---------|------|
+| 仕様とテストの一体化 | Clojure | Spec が仕様・検証・テスト生成を統合 |
+| 型駆動テスト生成 | Haskell | `Arbitrary` 型クラスで自動推論 |
+| 既存テストへの段階的導入 | Scala | ScalaTest との統合が容易 |
+| 宣言的テスト記述 | F# | `[<Property>]` 属性で最小限のボイラープレート |
+| マクロによる簡潔さ | Rust | `proptest!` マクロが定型コードを削減 |
+| ストリーム処理との統合 | Elixir | StreamData がデータ処理パイプラインと整合 |
+
+## 6. まとめ
+
+プロパティベーステストは、関数型プログラミングの**数学的性質**をテストに活かす手法です：
+
+1. **性質パターン**: 冪等性・対合性・不変量・往復は言語を問わず共通
+2. **ジェネレータ設計**: 静的型は自動推論、動的型は明示指定が基本
+3. **Spec 統合**: Clojure の Spec → PBT パイプラインは他言語にない強み
+4. **シュリンキング**: すべてのライブラリが最小反例の自動発見を提供
+
+## 言語別個別記事
+
+- [Clojure](../clojure/05-property-based-testing.md) | [Scala](../scala/05-property-based-testing.md) | [Elixir](../elixir/05-property-based-testing.md) | [F#](../fsharp/05-property-based-testing.md) | [Haskell](../haskell/05-property-based-testing.md) | [Rust](../rust/05-property-based-testing.md)