@k2works/claude-code-booster 4.7.0 → 4.9.0

package/lib/assets/docs/article/getting-start-tdd/clojure/11-persistent-data-and-pipeline.md

@@ -1,138 +1,138 @@
-# 第 11 章: 永続データ構造とパイプライン処理
-
-## 11.1 はじめに
-
-この章では Clojure の **永続データ構造**（Persistent Data Structures）と、それを活用した **パイプライン処理** を学びます。
-
-## 11.2 永続データ構造
-
-Clojure のデータ構造は **不変**（Immutable）です。「変更」操作は常に新しいデータ構造を返し、元のデータは変更されません。
-
-### 構造共有
-
-永続データ構造は **構造共有**（Structural Sharing）により、効率的にコピーなしで「変更」を実現します。
-
-```clojure
-(def original [1 2 3 4 5])
-(def modified (conj original 6))
-
-original  ;=> [1 2 3 4 5]   ← 変更されない
-modified  ;=> [1 2 3 4 5 6] ← 新しいベクタ
-```
-
-### 主要なデータ構造
-
-| データ構造 | リテラル | 特徴 |
-|-----------|----------|------|
-| ベクタ | `[1 2 3]` | インデックスアクセス O(log32 N) |
-| リスト | `'(1 2 3)` | 先頭追加 O(1) |
-| マップ | `{:a 1 :b 2}` | キーによるアクセス O(log32 N) |
-| セット | `#{1 2 3}` | 一意な値の集合 |
-
-### FizzBuzz での活用
-
-```clojure
-;; ベクタとして FizzBuzz リストを生成
-(def fizzbuzz-results
-  (mapv fizzbuzz (range 1 101)))
-
-;; マップで統計情報を集計
-(def stats
-  (->> fizzbuzz-results
-       (group-by identity)
-       (map (fn [[k v]] [k (count v)]))
-       (into {})))
-
-;; => {"1" 1, "2" 1, "Fizz" 27, "4" 1, "Buzz" 14, ...}
-```
-
-## 11.3 シーケンス抽象
-
-Clojure のシーケンス抽象は、すべてのコレクションに統一的なインターフェースを提供します。
-
-### 遅延シーケンス
-
-```clojure
-;; 無限の FizzBuzz シーケンス（遅延評価）
-(def infinite-fizzbuzz
-  (map fizzbuzz (iterate inc 1)))
-
-;; 必要な分だけ取得
-(take 15 infinite-fizzbuzz)
-;=> ("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz"
-;    "11" "Fizz" "13" "14" "FizzBuzz")
-```
-
-`iterate` は無限シーケンスを生成しますが、遅延評価のため実際にはアクセスした要素のみが計算されます。
-
-### トランスデューサー
-
-トランスデューサーは変換処理をコレクションから分離し、再利用可能にします。
-
-```clojure
-;; トランスデューサーの定義
-(def fizzbuzz-xf
-  (comp
-    (map fizzbuzz)
-    (filter #(re-matches #"[A-Za-z]+" %))))
-
-;; ベクタに適用
-(into [] fizzbuzz-xf (range 1 16))
-;=> ["Fizz" "Buzz" "Fizz" "Fizz" "Buzz" "Fizz" "FizzBuzz"]
-
-;; 文字列に適用
-(transduce fizzbuzz-xf str (range 1 16))
-;=> "FizzBuzzFizzFizzBuzzFizzFizzBuzz"
-```
-
-## 11.4 パイプライン処理
-
-### 実践的なパイプライン
-
-```clojure
-(defn fizzbuzz-report
-  "FizzBuzz の統計レポートを生成する"
-  [max-n]
-  (->> (range 1 (inc max-n))
-       (map fizzbuzz)
-       (group-by (fn [s]
-                   (cond
-                     (= s "FizzBuzz") :fizzbuzz
-                     (= s "Fizz") :fizz
-                     (= s "Buzz") :buzz
-                     :else :number)))
-       (map (fn [[k v]] [k (count v)]))
-       (into (sorted-map))))
-
-(fizzbuzz-report 100)
-;=> {:buzz 14, :fizz 27, :fizzbuzz 6, :number 53}
-```
-
-## 11.5 アトムによる状態管理
-
-不変データ構造を使いつつ、必要な場合にはアトムで状態を管理します。
-
-```clojure
-;; 処理カウンターの例
-(def process-count (atom 0))
-
-(defn counted-fizzbuzz [n]
-  (swap! process-count inc)
-  (fizzbuzz n))
-
-(map counted-fizzbuzz (range 1 6))
-@process-count ;=> 5
-```
-
-`atom` は Clojure の参照型の 1 つで、`swap!` で安全に状態を更新できます。
-
-## 11.6 まとめ
-
-この章では以下のことを学びました。
-
-- **永続データ構造** と **構造共有** の仕組み
-- ベクタ、マップ、セットなど主要なデータ構造の使い分け
-- **遅延シーケンス** による無限データの効率的な処理
-- **トランスデューサー** による変換処理の合成と再利用
-- **スレッディングマクロ** を使ったパイプライン処理
-- **アトム** による安全な状態管理
+# 第 11 章: 永続データ構造とパイプライン処理
+
+## 11.1 はじめに
+
+この章では Clojure の **永続データ構造**（Persistent Data Structures）と、それを活用した **パイプライン処理** を学びます。
+
+## 11.2 永続データ構造
+
+Clojure のデータ構造は **不変**（Immutable）です。「変更」操作は常に新しいデータ構造を返し、元のデータは変更されません。
+
+### 構造共有
+
+永続データ構造は **構造共有**（Structural Sharing）により、効率的にコピーなしで「変更」を実現します。
+
+```clojure
+(def original [1 2 3 4 5])
+(def modified (conj original 6))
+
+original  ;=> [1 2 3 4 5]   ← 変更されない
+modified  ;=> [1 2 3 4 5 6] ← 新しいベクタ
+```
+
+### 主要なデータ構造
+
+| データ構造 | リテラル | 特徴 |
+|-----------|----------|------|
+| ベクタ | `[1 2 3]` | インデックスアクセス O(log32 N) |
+| リスト | `'(1 2 3)` | 先頭追加 O(1) |
+| マップ | `{:a 1 :b 2}` | キーによるアクセス O(log32 N) |
+| セット | `#{1 2 3}` | 一意な値の集合 |
+
+### FizzBuzz での活用
+
+```clojure
+;; ベクタとして FizzBuzz リストを生成
+(def fizzbuzz-results
+  (mapv fizzbuzz (range 1 101)))
+
+;; マップで統計情報を集計
+(def stats
+  (->> fizzbuzz-results
+       (group-by identity)
+       (map (fn [[k v]] [k (count v)]))
+       (into {})))
+
+;; => {"1" 1, "2" 1, "Fizz" 27, "4" 1, "Buzz" 14, ...}
+```
+
+## 11.3 シーケンス抽象
+
+Clojure のシーケンス抽象は、すべてのコレクションに統一的なインターフェースを提供します。
+
+### 遅延シーケンス
+
+```clojure
+;; 無限の FizzBuzz シーケンス（遅延評価）
+(def infinite-fizzbuzz
+  (map fizzbuzz (iterate inc 1)))
+
+;; 必要な分だけ取得
+(take 15 infinite-fizzbuzz)
+;=> ("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz"
+;    "11" "Fizz" "13" "14" "FizzBuzz")
+```
+
+`iterate` は無限シーケンスを生成しますが、遅延評価のため実際にはアクセスした要素のみが計算されます。
+
+### トランスデューサー
+
+トランスデューサーは変換処理をコレクションから分離し、再利用可能にします。
+
+```clojure
+;; トランスデューサーの定義
+(def fizzbuzz-xf
+  (comp
+    (map fizzbuzz)
+    (filter #(re-matches #"[A-Za-z]+" %))))
+
+;; ベクタに適用
+(into [] fizzbuzz-xf (range 1 16))
+;=> ["Fizz" "Buzz" "Fizz" "Fizz" "Buzz" "Fizz" "FizzBuzz"]
+
+;; 文字列に適用
+(transduce fizzbuzz-xf str (range 1 16))
+;=> "FizzBuzzFizzFizzBuzzFizzFizzBuzz"
+```
+
+## 11.4 パイプライン処理
+
+### 実践的なパイプライン
+
+```clojure
+(defn fizzbuzz-report
+  "FizzBuzz の統計レポートを生成する"
+  [max-n]
+  (->> (range 1 (inc max-n))
+       (map fizzbuzz)
+       (group-by (fn [s]
+                   (cond
+                     (= s "FizzBuzz") :fizzbuzz
+                     (= s "Fizz") :fizz
+                     (= s "Buzz") :buzz
+                     :else :number)))
+       (map (fn [[k v]] [k (count v)]))
+       (into (sorted-map))))
+
+(fizzbuzz-report 100)
+;=> {:buzz 14, :fizz 27, :fizzbuzz 6, :number 53}
+```
+
+## 11.5 アトムによる状態管理
+
+不変データ構造を使いつつ、必要な場合にはアトムで状態を管理します。
+
+```clojure
+;; 処理カウンターの例
+(def process-count (atom 0))
+
+(defn counted-fizzbuzz [n]
+  (swap! process-count inc)
+  (fizzbuzz n))
+
+(map counted-fizzbuzz (range 1 6))
+@process-count ;=> 5
+```
+
+`atom` は Clojure の参照型の 1 つで、`swap!` で安全に状態を更新できます。
+
+## 11.6 まとめ
+
+この章では以下のことを学びました。
+
+- **永続データ構造** と **構造共有** の仕組み
+- ベクタ、マップ、セットなど主要なデータ構造の使い分け
+- **遅延シーケンス** による無限データの効率的な処理
+- **トランスデューサー** による変換処理の合成と再利用
+- **スレッディングマクロ** を使ったパイプライン処理
+- **アトム** による安全な状態管理

package/lib/assets/docs/article/getting-start-tdd/clojure/12-error-handling-and-spec.md

@@ -1,161 +1,161 @@
-# 第 12 章: エラーハンドリングと Spec
-
-## 12.1 はじめに
-
-この章では Clojure のエラーハンドリングと、**clojure.spec** によるデータバリデーションを学びます。
-
-## 12.2 例外処理
-
-### try / catch / finally
-
-Clojure は JVM 上で動作するため、Java の例外機構を利用できます。
-
-```clojure
-(try
-  (type/generate-string (type/->FizzBuzzTypeNotDefined)
-                        (model/create-fizz-buzz-value 1))
-  (catch clojure.lang.ExceptionInfo e
-    (println "エラー:" (ex-message e))
-    (println "データ:" (ex-data e))))
-;; エラー: FizzBuzz タイプが未定義です
-;; データ: {:type :not-defined}
-```
-
-### ex-info による構造化エラー
-
-`ex-info` は例外にデータマップを付与できる Clojure 固有の関数です。
-
-```clojure
-;; 例外の生成
-(throw (ex-info "FizzBuzz タイプが未定義です"
-                {:type :not-defined
-                 :requested-type 99}))
-
-;; 例外データの取得
-(try
-  (cmd/execute (cmd/->FizzBuzzValueCommand 1 99))
-  (catch clojure.lang.ExceptionInfo e
-    {:message (ex-message e)
-     :data (ex-data e)}))
-;=> {:message "FizzBuzz タイプが未定義です"
-;    :data {:type :not-defined}}
-```
-
-### ex-info vs Java 例外
-
-| 特徴 | ex-info | Java 例外 |
-|------|---------|-----------|
-| データ付与 | マップで構造化データ | メッセージ文字列のみ |
-| 型 | `ExceptionInfo` | 任意の例外クラス |
-| 活用 | ビジネスロジック | システムレベル |
-
-## 12.3 条件分岐によるエラー処理
-
-### nil を活用したエラー処理
-
-```clojure
-;; some-> マクロ（nil ならショートサーキット）
-(some-> 15
-        model/create-fizz-buzz-value
-        (->> (type/generate-string (type/->FizzBuzzType01))))
-;=> "FizzBuzz"
-
-(some-> nil
-        model/create-fizz-buzz-value
-        (->> (type/generate-string (type/->FizzBuzzType01))))
-;=> nil
-```
-
-### when-let / if-let
-
-```clojure
-(defn safe-fizzbuzz [n]
-  (when-let [value (and (pos? n) (model/create-fizz-buzz-value n))]
-    (type/generate-string (type/->FizzBuzzType01) value)))
-
-(safe-fizzbuzz 3)   ;=> "Fizz"
-(safe-fizzbuzz -1)  ;=> nil
-```
-
-## 12.4 clojure.spec によるバリデーション
-
-### Spec の定義
-
-`clojure.spec.alpha` を使って、データの仕様を宣言的に定義します。
-
-```clojure
-(require '[clojure.spec.alpha :as s])
-
-;; 基本的な Spec 定義
-(s/def ::number pos-int?)
-(s/def ::type-num #{1 2 3})
-(s/def ::fizzbuzz-string (s/or :number string?
-                               :fizz #(= % "Fizz")
-                               :buzz #(= % "Buzz")
-                               :fizzbuzz #(= % "FizzBuzz")))
-```
-
-### バリデーション
-
-```clojure
-;; 値の検証
-(s/valid? ::number 5)     ;=> true
-(s/valid? ::number -1)    ;=> false
-(s/valid? ::type-num 1)   ;=> true
-(s/valid? ::type-num 99)  ;=> false
-
-;; エラー情報の取得
-(s/explain-data ::number -1)
-;=> {:problems [{:path [], :pred pos-int?, :val -1, :via [::number], :in []}]}
-```
-
-### 関数仕様の定義
-
-```clojure
-(s/fdef fizzbuzz
-  :args (s/cat :n ::number)
-  :ret string?)
-
-;; 仕様に基づくテスト生成
-(require '[clojure.spec.test.alpha :as stest])
-(stest/check `fizzbuzz)
-```
-
-### コマンドの Spec
-
-```clojure
-(s/def ::fizzbuzz-value-command
-  (s/keys :req-un [::number ::type-num]))
-
-(s/valid? ::fizzbuzz-value-command
-          {:number 15 :type-num 1})
-;=> true
-```
-
-## 12.5 テストでの活用
-
-```clojure
-(deftest error-handling-test
-  (testing "未定義タイプでコマンド実行すると例外が発生する"
-    (is (thrown? clojure.lang.ExceptionInfo
-                 (cmd/execute (cmd/->FizzBuzzValueCommand 1 99)))))
-
-  (testing "例外のデータを検証する"
-    (try
-      (cmd/execute (cmd/->FizzBuzzValueCommand 1 99))
-      (catch clojure.lang.ExceptionInfo e
-        (is (= {:type :not-defined} (ex-data e)))))))
-```
-
-## 12.6 まとめ
-
-この章では以下のことを学びました。
-
-- **try / catch / finally** による例外処理
-- **ex-info / ex-data** による構造化エラー情報
-- **some->** や **when-let** による nil 安全なエラー処理
-- **clojure.spec** によるデータバリデーション
-- **s/fdef** による関数仕様の定義
-- テストでの例外検証パターン
-
-第 4 部が完了しました。Clojure の関数型プログラミングの全体像を学びました。高階関数、永続データ構造、パイプライン処理、そして Spec によるデータバリデーションが Clojure プログラミングの強力な基盤となります。
+# 第 12 章: エラーハンドリングと Spec
+
+## 12.1 はじめに
+
+この章では Clojure のエラーハンドリングと、**clojure.spec** によるデータバリデーションを学びます。
+
+## 12.2 例外処理
+
+### try / catch / finally
+
+Clojure は JVM 上で動作するため、Java の例外機構を利用できます。
+
+```clojure
+(try
+  (type/generate-string (type/->FizzBuzzTypeNotDefined)
+                        (model/create-fizz-buzz-value 1))
+  (catch clojure.lang.ExceptionInfo e
+    (println "エラー:" (ex-message e))
+    (println "データ:" (ex-data e))))
+;; エラー: FizzBuzz タイプが未定義です
+;; データ: {:type :not-defined}
+```
+
+### ex-info による構造化エラー
+
+`ex-info` は例外にデータマップを付与できる Clojure 固有の関数です。
+
+```clojure
+;; 例外の生成
+(throw (ex-info "FizzBuzz タイプが未定義です"
+                {:type :not-defined
+                 :requested-type 99}))
+
+;; 例外データの取得
+(try
+  (cmd/execute (cmd/->FizzBuzzValueCommand 1 99))
+  (catch clojure.lang.ExceptionInfo e
+    {:message (ex-message e)
+     :data (ex-data e)}))
+;=> {:message "FizzBuzz タイプが未定義です"
+;    :data {:type :not-defined}}
+```
+
+### ex-info vs Java 例外
+
+| 特徴 | ex-info | Java 例外 |
+|------|---------|-----------|
+| データ付与 | マップで構造化データ | メッセージ文字列のみ |
+| 型 | `ExceptionInfo` | 任意の例外クラス |
+| 活用 | ビジネスロジック | システムレベル |
+
+## 12.3 条件分岐によるエラー処理
+
+### nil を活用したエラー処理
+
+```clojure
+;; some-> マクロ（nil ならショートサーキット）
+(some-> 15
+        model/create-fizz-buzz-value
+        (->> (type/generate-string (type/->FizzBuzzType01))))
+;=> "FizzBuzz"
+
+(some-> nil
+        model/create-fizz-buzz-value
+        (->> (type/generate-string (type/->FizzBuzzType01))))
+;=> nil
+```
+
+### when-let / if-let
+
+```clojure
+(defn safe-fizzbuzz [n]
+  (when-let [value (and (pos? n) (model/create-fizz-buzz-value n))]
+    (type/generate-string (type/->FizzBuzzType01) value)))
+
+(safe-fizzbuzz 3)   ;=> "Fizz"
+(safe-fizzbuzz -1)  ;=> nil
+```
+
+## 12.4 clojure.spec によるバリデーション
+
+### Spec の定義
+
+`clojure.spec.alpha` を使って、データの仕様を宣言的に定義します。
+
+```clojure
+(require '[clojure.spec.alpha :as s])
+
+;; 基本的な Spec 定義
+(s/def ::number pos-int?)
+(s/def ::type-num #{1 2 3})
+(s/def ::fizzbuzz-string (s/or :number string?
+                               :fizz #(= % "Fizz")
+                               :buzz #(= % "Buzz")
+                               :fizzbuzz #(= % "FizzBuzz")))
+```
+
+### バリデーション
+
+```clojure
+;; 値の検証
+(s/valid? ::number 5)     ;=> true
+(s/valid? ::number -1)    ;=> false
+(s/valid? ::type-num 1)   ;=> true
+(s/valid? ::type-num 99)  ;=> false
+
+;; エラー情報の取得
+(s/explain-data ::number -1)
+;=> {:problems [{:path [], :pred pos-int?, :val -1, :via [::number], :in []}]}
+```
+
+### 関数仕様の定義
+
+```clojure
+(s/fdef fizzbuzz
+  :args (s/cat :n ::number)
+  :ret string?)
+
+;; 仕様に基づくテスト生成
+(require '[clojure.spec.test.alpha :as stest])
+(stest/check `fizzbuzz)
+```
+
+### コマンドの Spec
+
+```clojure
+(s/def ::fizzbuzz-value-command
+  (s/keys :req-un [::number ::type-num]))
+
+(s/valid? ::fizzbuzz-value-command
+          {:number 15 :type-num 1})
+;=> true
+```
+
+## 12.5 テストでの活用
+
+```clojure
+(deftest error-handling-test
+  (testing "未定義タイプでコマンド実行すると例外が発生する"
+    (is (thrown? clojure.lang.ExceptionInfo
+                 (cmd/execute (cmd/->FizzBuzzValueCommand 1 99)))))
+
+  (testing "例外のデータを検証する"
+    (try
+      (cmd/execute (cmd/->FizzBuzzValueCommand 1 99))
+      (catch clojure.lang.ExceptionInfo e
+        (is (= {:type :not-defined} (ex-data e)))))))
+```
+
+## 12.6 まとめ
+
+この章では以下のことを学びました。
+
+- **try / catch / finally** による例外処理
+- **ex-info / ex-data** による構造化エラー情報
+- **some->** や **when-let** による nil 安全なエラー処理
+- **clojure.spec** によるデータバリデーション
+- **s/fdef** による関数仕様の定義
+- テストでの例外検証パターン
+
+第 4 部が完了しました。Clojure の関数型プログラミングの全体像を学びました。高階関数、永続データ構造、パイプライン処理、そして Spec によるデータバリデーションが Clojure プログラミングの強力な基盤となります。