@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,123 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "この章では Clojure の 高階関数 と 関数合成 を使って、FizzBuzz プログラムをより関数型らしいスタイルに変換します。"
-tags: [article, getting-start-tdd, clojure]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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

@@ -1,147 +0,0 @@
----
-type: Article
-title: "第 11 章: 永続データ構造とパイプライン処理"
-description: "この章では Clojure の 永続データ構造（Persistent Data Structures）と、それを活用した パイプライン処理 を学びます。"
-tags: [article, getting-start-tdd, clojure]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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,170 +0,0 @@
----
-type: Article
-title: "第 12 章: エラーハンドリングと Spec"
-description: "この章では Clojure のエラーハンドリングと、clojure.spec によるデータバリデーションを学びます。"
-tags: [article, getting-start-tdd, clojure]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 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 プログラミングの強力な基盤となります。

package/lib/assets/docs/article/getting-start-tdd/clojure/index.md

@@ -1,65 +0,0 @@
-# テスト駆動開発から始める Clojure 入門
-
-## 概要
-
-FizzBuzz 問題を題材に、テスト駆動開発（TDD）の基本サイクルから、開発環境の整備、プロトコルとマルチメソッドによるポリモーフィズム、関数型プログラミングの活用まで、Clojure の特徴を活かしながら段階的に学びます。
-
-## 対象読者
-
-- Clojure の基本文法を理解しているプログラミング学習者
-- TDD を体験してみたい開発者
-- LISP 系言語の関数型プログラミングと不変データ構造に興味がある方
-
-## 前提条件
-
-- Clojure 1.11 以降がインストールされていること
-- Leiningen が利用可能であること（Nix 環境推奨: `nix develop .#clojure`）
-
-## Clojure の特徴
-
-| 特徴 | 説明 |
-|------|------|
-| S 式（S-expression） | LISP 系のシンプルで統一された構文 |
-| 不変データ構造 | 永続データ構造による安全な並行処理 |
-| プロトコル | `defprotocol` による型ベースのポリモーフィズム |
-| マルチメソッド | `defmulti`/`defmethod` による値ベースのディスパッチ |
-| 高階関数 | `map`/`filter`/`reduce` を中心としたコレクション処理 |
-| スレッディングマクロ | `->`/`->>` によるパイプライン処理 |
-| JVM 上で動作 | Java ライブラリとの相互運用が可能 |
-
-## 開発ツール
-
-| ツール | 用途 |
-|--------|------|
-| [clojure.test](https://clojure.github.io/clojure/clojure.test-api.html) | 標準テスティングフレームワーク |
-| [Leiningen](https://leiningen.org/) | プロジェクト管理・ビルドツール |
-| [Eastwood](https://github.com/jonase/eastwood) | 静的コード解析（Linter） |
-| [Kibit](https://github.com/clj-commons/kibit) | イディオム検査 |
-| [cljfmt](https://github.com/weavejester/cljfmt) | コードフォーマッター |
-| [Makefile](https://www.gnu.org/software/make/) | タスクランナー |
-
-## 目次
-
-### 第 1 部: TDD の基本サイクル
-
-1. [第 1 章: TODO リストと最初のテスト](01-todo-list-and-first-test.md)
-2. [第 2 章: 仮実装と三角測量](02-fake-it-and-triangulation.md)
-3. [第 3 章: 明白な実装とリファクタリング](03-obvious-implementation-and-refactoring.md)
-
-### 第 2 部: 開発環境と自動化
-
-4. [第 4 章: バージョン管理と Conventional Commits](04-version-control-and-conventional-commits.md)
-5. [第 5 章: パッケージ管理と静的解析](05-package-management-and-static-analysis.md)
-6. [第 6 章: タスクランナーと CI/CD](06-task-runner-and-ci-cd.md)
-
-### 第 3 部: プロトコルとマルチメソッド
-
-7. [第 7 章: プロトコルとレコードによるポリモーフィズム](07-protocols-and-records.md)
-8. [第 8 章: マルチメソッドとデザインパターン](08-multimethods-and-design-patterns.md)
-9. [第 9 章: 名前空間とモジュール設計](09-namespaces-and-module-design.md)
-
-### 第 4 部: 関数型プログラミング
-
-10. [第 10 章: 高階関数と関数合成](10-higher-order-functions-and-composition.md)
-11. [第 11 章: 永続データ構造とパイプライン処理](11-persistent-data-and-pipeline.md)
-12. [第 12 章: エラーハンドリングと Spec](12-error-handling-and-spec.md)