@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/getting-start-tdd/clojure/07-protocols-and-records.md

@@ -0,0 +1,131 @@
+# 第 7 章: プロトコルとレコードによるポリモーフィズム
+
+## 7.1 はじめに
+
+この章からは FizzBuzz プログラムに追加仕様を実装しながら、Clojure におけるポリモーフィズムを学びます。Clojure は関数型言語ですが、`defprotocol` と `defrecord` による型ベースのポリモーフィズムを提供しています。
+
+### 追加仕様
+
+```
+1 から 100 までの数をプリントするプログラムを書け。
+ただし 3 の倍数のときは数の代わりに「Fizz」と、5 の倍数のときは「Buzz」とプリントし、
+3 と 5 両方の倍数の場合には「FizzBuzz」とプリントすること。
+タイプごとに出力を切り替えることができる。
+タイプ 1 は通常、タイプ 2 は数字のみ、タイプ 3 は FizzBuzz の場合のみをプリントする。
+```
+
+## 7.2 TODO リスト
+
+- [ ] タイプ 1 の場合（通常の FizzBuzz）
+- [ ] タイプ 2 の場合（数字のみ）
+- [ ] タイプ 3 の場合（FizzBuzz の場合のみ）
+- [ ] それ以外のタイプの場合（例外を発生）
+
+## 7.3 値オブジェクト — FizzBuzzValue
+
+### defrecord による不変データ構造
+
+Clojure の `defrecord` は不変のデータ構造を定義します。Java のクラスと異なり、フィールドは変更できません。
+
+```clojure
+;; src/fizzbuzz/domain/model.clj
+(ns fizzbuzz.domain.model)
+
+(defrecord FizzBuzzValue [number value])
+
+(defn create-fizz-buzz-value [n]
+  (->FizzBuzzValue n (str n)))
+```
+
+`->FizzBuzzValue` は自動生成されるコンストラクタ関数です。
+
+### 述語関数
+
+```clojure
+(defn fizz? [n]
+  (zero? (mod n 3)))
+
+(defn buzz? [n]
+  (zero? (mod n 5)))
+
+(defn fizz-buzz? [n]
+  (and (fizz? n) (buzz? n)))
+```
+
+Clojure の慣例として、述語関数（真偽値を返す関数）は名前の末尾に `?` を付けます。
+
+## 7.4 プロトコル — FizzBuzzType
+
+### defprotocol によるインターフェース定義
+
+`defprotocol` は Java のインターフェースに相当します。実装すべき関数のシグネチャを定義します。
+
+```clojure
+;; src/fizzbuzz/domain/type.clj
+(ns fizzbuzz.domain.type
+  (:require [fizzbuzz.domain.model :as model]))
+
+(defprotocol FizzBuzzType
+  "FizzBuzz タイプごとの文字列生成プロトコル"
+  (generate-string [this value]
+    "FizzBuzzValue から文字列を生成する"))
+```
+
+### レコードによるプロトコル実装
+
+各タイプをレコードとして定義し、プロトコルを実装します。
+
+```clojure
+;; タイプ 1: 通常の FizzBuzz
+(defrecord FizzBuzzType01 []
+  FizzBuzzType
+  (generate-string [_this value]
+    (let [n (:number value)]
+      (cond
+        (model/fizz-buzz? n) "FizzBuzz"
+        (model/fizz? n) "Fizz"
+        (model/buzz? n) "Buzz"
+        :else (str n)))))
+
+;; タイプ 2: 数字のみ
+(defrecord FizzBuzzType02 []
+  FizzBuzzType
+  (generate-string [_this value]
+    (str (:number value))))
+
+;; タイプ 3: FizzBuzz の場合のみ
+(defrecord FizzBuzzType03 []
+  FizzBuzzType
+  (generate-string [_this value]
+    (let [n (:number value)]
+      (cond
+        (model/fizz-buzz? n) "FizzBuzz"
+        (model/fizz? n) "Fizz"
+        (model/buzz? n) "Buzz"
+        :else ""))))
+```
+
+## 7.5 テストの実装
+
+```clojure
+;; test/fizzbuzz/domain/type_test.clj
+(deftest fizz-buzz-type01-test
+  (testing "タイプ 1: 通常の FizzBuzz"
+    (let [t (type/->FizzBuzzType01)]
+      (is (= "1" (type/generate-string t (model/create-fizz-buzz-value 1))))
+      (is (= "Fizz" (type/generate-string t (model/create-fizz-buzz-value 3))))
+      (is (= "Buzz" (type/generate-string t (model/create-fizz-buzz-value 5))))
+      (is (= "FizzBuzz" (type/generate-string t (model/create-fizz-buzz-value 15)))))))
+```
+
+テスト実行 → GREEN。
+
+## 7.6 まとめ
+
+この章では以下のことを学びました。
+
+- **defrecord** による不変データ構造（値オブジェクト）の定義
+- **defprotocol** によるインターフェースの定義
+- レコードによるプロトコルの実装（ポリモーフィズム）
+- 述語関数の命名規則（`?` サフィックス）
+- `let` によるローカルバインディング

package/lib/assets/docs/article/getting-start-tdd/clojure/08-multimethods-and-design-patterns.md

@@ -0,0 +1,130 @@
+# 第 8 章: マルチメソッドとデザインパターン
+
+## 8.1 はじめに
+
+前章ではプロトコルとレコードによるポリモーフィズムを学びました。この章では **マルチメソッド** による値ベースのディスパッチと、**デザインパターン** の Clojure 的な実現を学びます。
+
+## 8.2 マルチメソッド
+
+### defmulti / defmethod
+
+マルチメソッドは **値に基づいたディスパッチ** を行います。プロトコルが型に基づくのに対し、マルチメソッドは任意の値でディスパッチできます。
+
+```clojure
+;; ディスパッチ関数の定義
+(defmulti generate-by-type
+  "タイプ番号に基づいて FizzBuzz 文字列を生成する"
+  (fn [type-num _value] type-num))
+
+;; タイプごとの実装
+(defmethod generate-by-type 1 [_ value]
+  (let [n (:number value)]
+    (cond
+      (model/fizz-buzz? n) "FizzBuzz"
+      (model/fizz? n) "Fizz"
+      (model/buzz? n) "Buzz"
+      :else (str n))))
+
+(defmethod generate-by-type 2 [_ value]
+  (str (:number value)))
+
+(defmethod generate-by-type 3 [_ value]
+  (let [n (:number value)]
+    (cond
+      (model/fizz-buzz? n) "FizzBuzz"
+      (model/fizz? n) "Fizz"
+      (model/buzz? n) "Buzz"
+      :else "")))
+
+;; デフォルト（未定義タイプ）
+(defmethod generate-by-type :default [type-num _]
+  (throw (ex-info "FizzBuzz タイプが未定義です" {:type type-num})))
+```
+
+### プロトコル vs マルチメソッド
+
+| 特徴 | プロトコル | マルチメソッド |
+|------|-----------|--------------|
+| ディスパッチ基準 | 第 1 引数の型 | 任意の値 |
+| パフォーマンス | 高速（JVM レベル） | やや遅い |
+| 拡張性 | 型の追加で拡張 | メソッドの追加で拡張 |
+| 用途 | インターフェース設計 | 柔軟なディスパッチ |
+
+## 8.3 ファクトリ関数パターン
+
+Clojure ではクラスのコンストラクタの代わりにファクトリ関数を使います。
+
+```clojure
+(defn create-type [type-num]
+  (case type-num
+    1 (->FizzBuzzType01)
+    2 (->FizzBuzzType02)
+    3 (->FizzBuzzType03)
+    (->FizzBuzzTypeNotDefined)))
+```
+
+`case` は `switch` 文に相当し、定数値でのディスパッチに最適化されています。
+
+## 8.4 Command パターン
+
+### プロトコルによる Command パターン
+
+```clojure
+;; src/fizzbuzz/application/command.clj
+(defprotocol FizzBuzzCommand
+  "FizzBuzz コマンドプロトコル"
+  (execute [this]))
+
+;; 単一値コマンド
+(defrecord FizzBuzzValueCommand [number type-num]
+  FizzBuzzCommand
+  (execute [_this]
+    (let [fizz-buzz-type (type/create-type type-num)
+          value (model/create-fizz-buzz-value number)]
+      (type/generate-string fizz-buzz-type value))))
+
+;; リストコマンド
+(defrecord FizzBuzzListCommand [numbers type-num]
+  FizzBuzzCommand
+  (execute [_this]
+    (let [fizz-buzz-type (type/create-type type-num)]
+      (->> numbers
+           (mapv model/create-fizz-buzz-value)
+           (mapv #(type/generate-string fizz-buzz-type %))
+           model/create-fizz-buzz-list))))
+```
+
+### テスト
+
+```clojure
+(deftest fizz-buzz-value-command-test
+  (testing "FizzBuzzValueCommand: 単一値コマンド"
+    (is (= "1" (cmd/execute (cmd/->FizzBuzzValueCommand 1 1))))
+    (is (= "Fizz" (cmd/execute (cmd/->FizzBuzzValueCommand 3 1))))
+    (is (= "Buzz" (cmd/execute (cmd/->FizzBuzzValueCommand 5 1))))
+    (is (= "FizzBuzz" (cmd/execute (cmd/->FizzBuzzValueCommand 15 1))))))
+```
+
+## 8.5 Strategy パターン
+
+Clojure では高階関数が Strategy パターンの自然な表現です。
+
+```clojure
+(defn process-with-strategy [strategy-fn numbers]
+  (mapv strategy-fn numbers))
+
+;; 使用例
+(process-with-strategy fizzbuzz (range 1 101))
+```
+
+関数をファーストクラスの値として渡すことで、Strategy パターンが関数の引数渡しだけで実現できます。
+
+## 8.6 まとめ
+
+この章では以下のことを学びました。
+
+- **defmulti/defmethod** によるマルチメソッド（値ベースのディスパッチ）
+- プロトコルとマルチメソッドの使い分け
+- **ファクトリ関数** パターンと `case` 式
+- **Command パターン** のプロトコルによる実現
+- **Strategy パターン** の高階関数による実現

package/lib/assets/docs/article/getting-start-tdd/clojure/09-namespaces-and-module-design.md

@@ -0,0 +1,127 @@
+# 第 9 章: 名前空間とモジュール設計
+
+## 9.1 はじめに
+
+この章ではモノリシックなコードを名前空間に分割し、ドメインモデルに基づいたモジュール設計を行います。
+
+## 9.2 名前空間による分割
+
+### Before（モノリシック）
+
+```
+fizzbuzz/
+└── core.clj          (すべてのロジックが集中)
+```
+
+### After（モジュール分割）
+
+```
+fizzbuzz/
+├── core.clj                    (公開 API・エントリーポイント)
+├── domain/
+│   ├── model.clj               (値オブジェクト・コレクション)
+│   └── type.clj                (FizzBuzz タイプ — プロトコル実装)
+└── application/
+    └── command.clj             (コマンド関数)
+```
+
+## 9.3 名前空間の設計原則
+
+### 単一責任の原則
+
+各名前空間は 1 つの責務のみを持ちます。
+
+| 名前空間 | 責務 |
+|----------|------|
+| `fizzbuzz.core` | 公開 API とメインエントリーポイント |
+| `fizzbuzz.domain.model` | FizzBuzzValue と FizzBuzzList の定義 |
+| `fizzbuzz.domain.type` | タイプごとの文字列生成ロジック |
+| `fizzbuzz.application.command` | コマンドパターンの実装 |
+
+### 依存方向
+
+依存関係は常に上位レイヤーから下位レイヤーへ向かいます。
+
+```
+application/command → domain/type → domain/model
+                   ↗
+     core ────────
+```
+
+## 9.4 名前空間の require
+
+```clojure
+;; エイリアスを使った require
+(ns fizzbuzz.domain.type
+  (:require [fizzbuzz.domain.model :as model]))
+
+;; model/fizz? のようにエイリアス経由でアクセス
+(model/fizz? 3)  ;=> true
+```
+
+### require のベストプラクティス
+
+1. **`:as` エイリアス** を使う（名前の衝突を防ぐ）
+2. **`:refer :all`** は避ける（テストファイルでは許容）
+3. **循環依存** を作らない
+
+## 9.5 アクセス制御
+
+Clojure では `defn-` でプライベート関数を定義します。
+
+```clojure
+;; パブリック関数
+(defn fizzbuzz [n] ...)
+
+;; プライベート関数（同一名前空間内でのみアクセス可能）
+(defn- divisible-by? [n d]
+  (zero? (mod n d)))
+```
+
+## 9.6 レコードとプロトコルの配置
+
+### 推奨パターン
+
+- **プロトコルの定義**: 独立した名前空間に配置
+- **レコードの実装**: プロトコルを require して実装
+- **ファクトリ関数**: プロトコルと同じ名前空間に配置
+
+```clojure
+;; domain/type.clj にプロトコル定義とレコード実装を配置
+(defprotocol FizzBuzzType
+  (generate-string [this value]))
+
+(defrecord FizzBuzzType01 []
+  FizzBuzzType
+  (generate-string [_this value] ...))
+
+;; ファクトリ関数も同じ名前空間に
+(defn create-type [type-num] ...)
+```
+
+## 9.7 テスト名前空間の構成
+
+テストは対応するプロダクトコードと同じ構造で配置します。
+
+```
+test/
+└── fizzbuzz/
+    ├── core_test.clj
+    ├── domain/
+    │   └── type_test.clj
+    └── application/
+        └── command_test.clj
+```
+
+## 9.8 まとめ
+
+この章では以下のことを学びました。
+
+- **ns** マクロによる名前空間の定義と管理
+- **:require** と **:as** エイリアスによる依存関係の宣言
+- **単一責任の原則** に基づくモジュール設計
+- **defn-** によるアクセス制御
+- ドメインモデルに基づいた名前空間の分割パターン
+- テスト名前空間の構成
+
+第 3 部が完了しました。プロトコルとマルチメソッドによるポリモーフィズムと、名前空間によるモジュール設計を学びました。第 4 部では関数型プログラミングの本質を探ります。

package/lib/assets/docs/article/getting-start-tdd/clojure/10-higher-order-functions-and-composition.md

@@ -0,0 +1,114 @@
+# 第 10 章: 高階関数と関数合成
+
+## 10.1 はじめに
+
+この章では Clojure の **高階関数** と **関数合成** を使って、FizzBuzz プログラムをより関数型らしいスタイルに変換します。
+
+## 10.2 高階関数
+
+高階関数とは、関数を引数として受け取るか、関数を返す関数のことです。Clojure では関数がファーストクラスの値であり、変数に束縛したり、引数として渡したりできます。
+
+### map / filter / reduce
+
+```clojure
+;; map: 各要素に関数を適用
+(map fizzbuzz (range 1 16))
+;=> ("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz"
+;    "11" "Fizz" "13" "14" "FizzBuzz")
+
+;; filter: 条件を満たす要素のみ抽出
+(filter #(not= "" %) (map #(type/generate-string (type/->FizzBuzzType03)
+                                                  (model/create-fizz-buzz-value %))
+                          (range 1 16)))
+;=> ("Fizz" "Buzz" "Fizz" "Fizz" "Buzz" "Fizz" "FizzBuzz")
+
+;; reduce: 累積処理
+(reduce str (map fizzbuzz (range 1 6)))
+;=> "12FizzBuzz4"
+```
+
+### 部分適用（partial）
+
+`partial` は関数の一部の引数を固定して新しい関数を作ります。
+
+```clojure
+(def fizzbuzz-type1
+  (partial type/generate-string (type/->FizzBuzzType01)))
+
+(fizzbuzz-type1 (model/create-fizz-buzz-value 15))
+;=> "FizzBuzz"
+```
+
+### 無名関数
+
+```clojure
+;; fn による無名関数
+(map (fn [n] (fizzbuzz n)) (range 1 6))
+
+;; #() リーダーマクロによる短縮形
+(map #(fizzbuzz %) (range 1 6))
+```
+
+## 10.3 関数合成
+
+### comp による関数合成
+
+`comp` は複数の関数を合成して新しい関数を作ります。右から左へ適用されます。
+
+```clojure
+(def fizzbuzz-with-prefix
+  (comp (partial str "=> ") fizzbuzz))
+
+(fizzbuzz-with-prefix 3)
+;=> "=> Fizz"
+
+(fizzbuzz-with-prefix 15)
+;=> "=> FizzBuzz"
+```
+
+### スレッディングマクロ
+
+`->` と `->>` はデータの変換パイプラインを記述します。
+
+```clojure
+;; ->> マクロ（最後の引数に挿入）
+(->> (range 1 101)
+     (map fizzbuzz)
+     (filter #(re-matches #"[A-Za-z]+" %))
+     (take 5))
+;=> ("Fizz" "Buzz" "Fizz" "Fizz" "Buzz")
+
+;; -> マクロ（最初の引数に挿入）
+(-> 15
+    fizzbuzz
+    clojure.string/upper-case)
+;=> "FIZZBUZZ"
+```
+
+## 10.4 関数ファクトリ
+
+関数を返す関数を使って、カスタマイズ可能な処理を作れます。
+
+```clojure
+(defn create-fizzbuzz-filter
+  "指定パターンにマッチする FizzBuzz 結果をフィルタリングする関数を返す"
+  [pattern]
+  (fn [results]
+    (filter #(clojure.string/includes? % pattern) results)))
+
+(def fizz-filter (create-fizzbuzz-filter "Fizz"))
+(def buzz-filter (create-fizzbuzz-filter "Buzz"))
+
+(fizz-filter ["1" "Fizz" "Buzz" "FizzBuzz"])
+;=> ("Fizz" "FizzBuzz")
+```
+
+## 10.5 まとめ
+
+この章では以下のことを学びました。
+
+- **map / filter / reduce** による高階関数の活用
+- **partial** による部分適用
+- **comp** による関数合成
+- **スレッディングマクロ**（`->`、`->>`）によるパイプライン処理
+- **関数ファクトリ**（関数を返す関数）パターン

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

@@ -0,0 +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 まとめ
+
+この章では以下のことを学びました。
+
+- **永続データ構造** と **構造共有** の仕組み
+- ベクタ、マップ、セットなど主要なデータ構造の使い分け
+- **遅延シーケンス** による無限データの効率的な処理
+- **トランスデューサー** による変換処理の合成と再利用
+- **スレッディングマクロ** を使ったパイプライン処理
+- **アトム** による安全な状態管理