npm - @k2works/claude-code-booster - Versions diffs - 4.9.0 → 4.11.0 - Mend

@k2works/claude-code-booster 4.9.0 → 4.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (747) hide show

package/lib/assets/docs/article/grokkingfp/clojure/part-4.md CHANGED Viewed

@@ -1,697 +1,697 @@
-# Part IV: 状態管理とストリーム処理（Clojure 版）
-本章では、Clojure における副作用の扱い方を学びます。atom による状態管理、遅延評価、非同期処理、そして遅延シーケンスとトランスデューサーによるストリーム処理を習得します。
----
-## 第8章: 状態管理と副作用
-### 8.1 副作用の問題
-純粋関数は副作用を持ちません。しかし、実際のプログラムには副作用が必要です:
-- 状態の変更
-- ファイルの読み書き
-- ネットワーク通信
-- 乱数生成
-- 現在時刻の取得
-```plantuml
-@startuml
-!theme plain
-rectangle "副作用の問題" {
-  rectangle "副作用を持つ関数" as impure {
-    card "テストが困難"
-    card "予測不可能"
-    card "参照透過性がない"
-  }
-  rectangle "純粋関数" as pure {
-    card "テストが容易"
-    card "予測可能"
-    card "参照透過性がある"
-  }
-}
-note bottom
-  Clojure では副作用を
-  明確に分離して扱う
-end note
-@enduml
-```
-### 8.2 Clojure の副作用管理
-Clojure には副作用を管理するための複数のメカニズムがあります。
-```plantuml
-@startuml
-!theme plain
-rectangle "Clojure の副作用管理" {
-  card "delay" as delay
-  card "atom" as atom
-  card "future" as future
-  card "promise" as promise
-}
-note right of delay
-  遅延評価
-end note
-note right of atom
-  状態管理
-end note
-note right of future
-  非同期処理
-end note
-note right of promise
-  同期プリミティブ
-end note
-note bottom
-  Scala の IO モナドとは異なり
-  Clojure は実用的なアプローチを取る
-end note
-@enduml
-```
-### 8.3 サイコロを振る例
-**ソースファイル**: `app/clojure/src/ch08/state_management.clj`
-#### 不純な関数（副作用あり）
-```clojure
-(defn cast-the-die-impure!
-  "サイコロを振る（不純）"
-  []
-  (inc (rand-int 6)))
-;; 呼び出すたびに異なる値が返る
-(cast-the-die-impure!) ; => 3
-(cast-the-die-impure!) ; => 5
-(cast-the-die-impure!) ; => 1
-```
-#### delay を使った遅延評価
-```clojure
-(defn cast-the-die
-  "サイコロを振る（遅延）"
-  []
-  (delay (cast-the-die-impure!)))
-;; delay を作成しただけでは実行されない
-(def die-cast (cast-the-die))
-die-cast ; => #<Delay@...>
-;; force で実行
-(force die-cast) ; => 4
-```
-> **注意**: `delay` は一度だけ評価され、結果がキャッシュされます。毎回実行するには新しい `delay` を作成するか、関数でラップします。
-### 8.4 atom による状態管理
-**atom** は Clojure の最も基本的な状態管理プリミティブです。Scala の `Ref` に相当します。
-```plantuml
-@startuml
-!theme plain
-rectangle "atom の操作" {
-  card "atom" as create
-  card "@atom (deref)" as read
-  card "swap!" as swap
-  card "reset!" as reset
-  create --> read : 値を読み取り
-  create --> swap : 関数を適用して更新
-  create --> reset : 値を直接設定
-}
-@enduml
-```
-```clojure
-;; atom を作成
-(def counter (atom 0))
-;; 値を読み取り
-@counter            ; => 0
-(deref counter)     ; => 0
-;; swap! で関数を適用して更新
-(swap! counter inc) ; => 1
-(swap! counter + 5) ; => 6
-;; reset! で値を直接設定
-(reset! counter 0)  ; => 0
-```
-### 8.5 atom の高度な操作
-```clojure
-;; compare-and-set! は期待値と一致する場合のみ更新
-(def a (atom 5))
-(compare-and-set! a 5 10) ; => true, @a = 10
-(compare-and-set! a 5 20) ; => false, @a = 10（変更されない）
-;; 複数の値を持つ atom
-(def game-state (atom {:rolls [] :total 0}))
-(defn roll-die!
-  "サイコロを振って状態を更新"
-  []
-  (let [roll (cast-the-die-impure!)]
-    (swap! game-state
-           (fn [state]
-             (-> state
-                 (update :rolls conj roll)
-                 (update :total + roll))))
-    roll))
-```
-### 8.6 future による非同期処理
-**future** は別スレッドで計算を実行します。
-```clojure
-;; future を作成
-(def f (future
-         (Thread/sleep 1000)
-         (+ 1 2)))
-;; deref で結果を取得（完了まで待機）
-@f ; => 3
-;; タイムアウト付きで取得
-(deref f 500 :timeout) ; => :timeout または結果
-```
-#### 並列 API 呼び出し
-```clojure
-(defn async-api-call
-  "非同期 API 呼び出しをシミュレート"
-  [name delay-ms]
-  (future
-    (Thread/sleep delay-ms)
-    {:name name :result (str "Result for " name)}))
-(defn parallel-api-calls
-  "並列で API を呼び出す"
-  [names]
-  (let [futures (mapv #(async-api-call % 100) names)]
-    (mapv deref futures)))
-(parallel-api-calls ["a" "b" "c"])
-; => [{:name "a" ...} {:name "b" ...} {:name "c" ...}]
-```
-### 8.7 promise による同期
-**promise** は一度だけ値を設定できるコンテナです。
-```clojure
-;; promise を作成
-(def p (promise))
-;; 値を設定
-(deliver p 42)
-;; 値を取得
-@p ; => 42
-;; タイムアウト付き
-(deref p 100 :default) ; => 42 または :default
-```
-### 8.8 ミーティングスケジューリングの例
-```clojure
-(defn meeting-time [start-hour end-hour]
-  {:start-hour start-hour :end-hour end-hour})
-(defn meetings-overlap?
-  "2つのミーティングが重複するか"
-  [m1 m2]
-  (not (or (>= (:start-hour m1) (:end-hour m2))
-           (>= (:start-hour m2) (:end-hour m1)))))
-(defn possible-meetings
-  "空き時間を計算（純粋関数）"
-  [existing-meetings start-hour end-hour length-hours]
-  (let [slots (for [start (range start-hour (- end-hour length-hours -1))]
-                (meeting-time start (+ start length-hours)))]
-    (filter (fn [slot]
-              (not-any? #(meetings-overlap? % slot) existing-meetings))
-            slots)))
-```
-### 8.9 リトライ戦略
-```clojure
-(defn retry
-  "アクションを n 回リトライ"
-  [action max-retries]
-  (loop [attempts 0]
-    (let [result (try
-                   {:ok (action)}
-                   (catch Exception e
-                     {:error (.getMessage e)}))]
-      (if (or (:ok result) (>= attempts max-retries))
-        result
-        (recur (inc attempts))))))
-(defn retry-with-delay
-  "遅延付きでリトライ"
-  [action max-retries delay-ms]
-  (loop [attempts 0]
-    (let [result (try
-                   {:ok (action)}
-                   (catch Exception e
-                     {:error (.getMessage e)}))]
-      (if (or (:ok result) (>= attempts max-retries))
-        result
-        (do
-          (Thread/sleep delay-ms)
-          (recur (inc attempts)))))))
-```
-### 8.10 副作用の分離パターン
-```plantuml
-@startuml
-!theme plain
-rectangle "副作用の分離" {
-  rectangle "純粋なコア" as core {
-    card "calculate-discount"
-    card "calculate-total"
-  }
-  rectangle "副作用を持つシェル" as shell {
-    card "save-order!"
-    card "get-order"
-  }
-  core <-- shell : 使用
-}
-note bottom
-  ビジネスロジックを純粋関数に
-  副作用を境界に押し出す
-end note
-@enduml
-```
-```clojure
-;; 純粋なコアロジック
-(defn calculate-discount [price discount-rate]
-  (* price (- 1 discount-rate)))
-(defn calculate-total [items]
-  (reduce + (map :price items)))
-;; 副作用を持つシェル
-(def order-db (atom {}))
-(defn save-order! [order-id order]
-  (swap! order-db assoc order-id order)
-  order-id)
-;; 副作用を分離した処理
-(defn process-order! [order-id items discount-rate]
-  (let [subtotal (calculate-total items)          ; 純粋
-        total (calculate-discount subtotal discount-rate)]  ; 純粋
-    (save-order! order-id {:items items          ; 副作用
-                           :subtotal subtotal
-                           :total total})))
-```
----
-## 第9章: 遅延シーケンスとストリーム処理
-### 9.1 遅延シーケンスとは
-Clojure のシーケンスは**遅延評価**されます。要素は必要になるまで計算されません。
-```plantuml
-@startuml
-!theme plain
-rectangle "遅延シーケンス" {
-  card "(range)" as infinite
-  card "(take 5 ...)" as take
-  card "(1 2 3 4 5)" as result
-  infinite --> take : 必要な分だけ
-  take --> result : 実体化
-}
-note bottom
-  無限シーケンスも
-  必要な分だけ計算
-end note
-@enduml
-```
-### 9.2 lazy-seq による遅延シーケンス
-```clojure
-(defn lazy-range
-  "遅延範囲シーケンス"
-  [start end]
-  (lazy-seq
-   (when (< start end)
-     (cons start (lazy-range (inc start) end)))))
-;; range は遅延シーケンス
-(def numbers (range 1 11))
-;; まだ評価されていない
-;; take で必要な分だけ取得
-(take 3 numbers)  ; => (1 2 3)
-```
-### 9.3 無限シーケンス
-Clojure には無限シーケンスを生成する関数があります。
-| 関数 | 説明 | 例 |
-|------|------|-----|
-| `repeat` | 同じ値を無限に繰り返す | `(take 5 (repeat 1))` => `(1 1 1 1 1)` |
-| `iterate` | 関数を繰り返し適用 | `(take 5 (iterate inc 0))` => `(0 1 2 3 4)` |
-| `cycle` | シーケンスを無限に繰り返す | `(take 5 (cycle [1 2]))` => `(1 2 1 2 1)` |
-| `repeatedly` | 関数を無限に呼び出す | `(take 3 (repeatedly rand))` |
-```clojure
-;; 2のべき乗
-(def powers-of-2 (iterate #(* 2 %) 1))
-(take 10 powers-of-2)
-; => (1 2 4 8 16 32 64 128 256 512)
-;; 無限のサイコロ
-(def infinite-die-rolls (repeatedly #(inc (rand-int 6))))
-(take 5 infinite-die-rolls) ; => (3 1 5 2 4)
-```
-### 9.4 遅延シーケンスの操作
-```clojure
-(defn process-stream
-  "ストリームを処理"
-  [stream]
-  (->> stream
-       (filter odd?)
-       (map #(* % %))
-       (take 5)))
-(process-stream (range))
-; => (1 9 25 49 81)
-;; take-while: 条件を満たす間取得
-(take-while pos? [1 2 3 -1 4 5])
-; => (1 2 3)
-;; drop-while: 条件を満たす間スキップ
-(drop-while #(< % 5) [1 2 3 4 5 6 7])
-; => (5 6 7)
-```
-### 9.5 スライディングウィンドウ
-```plantuml
-@startuml
-!theme plain
-rectangle "スライディングウィンドウ" {
-  card "[1 2 3 4 5]" as input
-  card "(partition 3 1 ...)" as part
-  card "((1 2 3) (2 3 4) (3 4 5))" as output
-  input --> part
-  part --> output
-}
-@enduml
-```
-```clojure
-;; partition: 指定サイズで分割
-(partition 3 (range 10))
-; => ((0 1 2) (3 4 5) (6 7 8))
-;; partition-all: 端数も含める
-(partition-all 3 (range 10))
-; => ((0 1 2) (3 4 5) (6 7 8) (9))
-;; partition with step: スライディングウィンドウ
-(defn sliding-window [n coll]
-  (partition n 1 coll))
-(sliding-window 3 [1 2 3 4 5])
-; => ((1 2 3) (2 3 4) (3 4 5))
-```
-### 9.6 トレンド検出
-為替レートの上昇・下降トレンドを検出します。
-```clojure
-(defn trending?
-  "上昇トレンドかどうか"
-  [rates]
-  (and (> (count rates) 1)
-       (every? (fn [[prev curr]] (< prev curr))
-               (partition 2 1 rates))))
-(trending? [0.81 0.82 0.83])  ; => true
-(trending? [0.81 0.84 0.83])  ; => false
-(defn declining?
-  "下降トレンドかどうか"
-  [rates]
-  (and (> (count rates) 1)
-       (every? (fn [[prev curr]] (> prev curr))
-               (partition 2 1 rates))))
-(defn find-trend
-  "トレンドを検出"
-  [window-size stream]
-  (->> stream
-       (sliding-window window-size)
-       (map (fn [window]
-              {:rates (vec window)
-               :trending? (trending? window)
-               :declining? (declining? window)}))))
-```
-### 9.7 reductions（スキャン操作）
-`reductions` は `reduce` の中間結果をすべて返します。Scala の `scanLeft` に相当します。
-```clojure
-;; 累積和
-(reductions + (range 1 6))
-; => (1 3 6 10 15)
-;; 移動平均
-(defn moving-average [window-size coll]
-  (->> coll
-       (sliding-window window-size)
-       (map #(/ (reduce + %) (count %)))))
-(moving-average 3 [1 2 3 4 5 6 7 8 9 10])
-; => (2 3 4 5 6 7 8 9)
-```
-### 9.8 トランスデューサー
-**トランスデューサー**は変換を合成する効率的な方法です。中間コレクションを作らずに処理できます。
-```plantuml
-@startuml
-!theme plain
-rectangle "通常のチェーン" {
-  card "coll" as c1
-  card "filter" as f1
-  card "中間coll" as c2
-  card "map" as m1
-  card "中間coll" as c3
-  card "take" as t1
-  card "結果" as r1
-  c1 --> f1
-  f1 --> c2
-  c2 --> m1
-  m1 --> c3
-  c3 --> t1
-  t1 --> r1
-}
-rectangle "トランスデューサー" {
-  card "coll" as c4
-  card "comp(filter, map, take)" as comp1
-  card "結果" as r2
-  c4 --> comp1
-  comp1 --> r2
-}
-note bottom of comp1
-  中間コレクションなし
-  一度のパスで処理
-end note
-@enduml
-```
-```clojure
-;; トランスデューサーを合成
-(def xform
-  (comp
-   (filter odd?)
-   (map #(* % %))
-   (take 5)))
-;; into で使用
-(into [] xform (range 20))
-; => [1 9 25 49 81]
-;; sequence で遅延処理
-(sequence xform (range 20))
-; => (1 9 25 49 81)
-```
-### 9.9 eduction
-`eduction` はトランスデューサーを使った効率的な遅延処理です。
-```clojure
-(defn efficient-process [coll]
-  (eduction
-   (filter odd?)
-   (map #(* % %))
-   (take 5)
-   coll))
-;; reduce, into, run! などと組み合わせて使用
-(into [] (efficient-process (range 20)))
-; => [1 9 25 49 81]
-```
-### 9.10 実践例：ログストリーム処理
-```clojure
-(def log-levels #{:debug :info :warn :error})
-(defn generate-log-entry []
-  {:timestamp (System/currentTimeMillis)
-   :level (rand-nth (vec log-levels))
-   :message (str "Log message " (rand-int 1000))})
-(def log-stream (repeatedly generate-log-entry))
-(defn filter-errors [logs]
-  (filter #(= :error (:level %)) logs))
-(defn count-by-level [logs]
-  (frequencies (map :level logs)))
-(defn recent-errors [n logs]
-  (->> logs
-       filter-errors
-       (take n)))
-```
-### 9.11 実践例：センサーデータストリーム
-```clojure
-(defn sensor-stream [base-value variance]
-  (repeatedly #(+ base-value (* (- (rand) 0.5) variance))))
-(defn detect-anomalies [threshold stream]
-  (filter #(> (Math/abs (- % 50)) threshold) stream))
-(defn alert-on-anomaly [threshold n stream]
-  (->> stream
-       (detect-anomalies threshold)
-       (take n)
-       (map (fn [value]
-              {:type :anomaly
-               :value value
-               :timestamp (System/currentTimeMillis)}))))
-```
-### 9.12 バッチ処理
-```clojure
-(defn process-in-batches [batch-size process-fn coll]
-  (->> coll
-       (partition-all batch-size)
-       (map process-fn)))
-(defn batch-sum [batch-size coll]
-  (process-in-batches batch-size #(reduce + %) coll))
-(batch-sum 3 [1 2 3 4 5 6 7 8 9 10])
-; => (6 15 24 10)
-```
-### 9.13 パイプライン処理
-```clojure
-(defn pipeline [& fns]
-  (fn [coll]
-    (reduce (fn [acc f] (f acc)) coll fns)))
-(def my-pipeline
-  (pipeline
-   (partial filter odd?)
-   (partial map #(* % 2))
-   (partial take 5)))
-(my-pipeline (range 20))
-; => (2 6 10 14 18)
-```
----
-## まとめ
-### Clojure vs Scala の比較
-| 概念 | Scala (cats-effect) | Clojure |
-|------|---------------------|---------|
-| 副作用の遅延 | `IO.delay` | `delay` / 関数 |
-| 状態管理 | `Ref[IO, A]` | `atom` |
-| 非同期処理 | `IO.async` | `future` |
-| 同期プリミティブ | `Deferred` | `promise` |
-| ストリーム処理 | fs2 `Stream` | 遅延シーケンス |
-| 変換の合成 | パイプ演算子 | トランスデューサー |
-### 学んだこと
-1. **状態管理**: atom を使った安全な状態管理
-2. **遅延評価**: delay と force による遅延実行
-3. **非同期処理**: future と promise による並行プログラミング
-4. **遅延シーケンス**: 無限シーケンスと遅延評価
-5. **トランスデューサー**: 効率的な変換の合成
-6. **副作用の分離**: 純粋なコアと副作用を持つシェル
-### 次のステップ
-- Part V では、関数型プログラミングの高度なテクニックを学びます
-- Part VI では、実践的なアプリケーション開発を行います
+# Part IV: 状態管理とストリーム処理（Clojure 版）
+本章では、Clojure における副作用の扱い方を学びます。atom による状態管理、遅延評価、非同期処理、そして遅延シーケンスとトランスデューサーによるストリーム処理を習得します。
+---
+## 第8章: 状態管理と副作用
+### 8.1 副作用の問題
+純粋関数は副作用を持ちません。しかし、実際のプログラムには副作用が必要です:
+- 状態の変更
+- ファイルの読み書き
+- ネットワーク通信
+- 乱数生成
+- 現在時刻の取得
+```plantuml
+@startuml
+!theme plain
+rectangle "副作用の問題" {
+  rectangle "副作用を持つ関数" as impure {
+    card "テストが困難"
+    card "予測不可能"
+    card "参照透過性がない"
+  }
+  rectangle "純粋関数" as pure {
+    card "テストが容易"
+    card "予測可能"
+    card "参照透過性がある"
+  }
+}
+note bottom
+  Clojure では副作用を
+  明確に分離して扱う
+end note
+@enduml
+```
+### 8.2 Clojure の副作用管理
+Clojure には副作用を管理するための複数のメカニズムがあります。
+```plantuml
+@startuml
+!theme plain
+rectangle "Clojure の副作用管理" {
+  card "delay" as delay
+  card "atom" as atom
+  card "future" as future
+  card "promise" as promise
+}
+note right of delay
+  遅延評価
+end note
+note right of atom
+  状態管理
+end note
+note right of future
+  非同期処理
+end note
+note right of promise
+  同期プリミティブ
+end note
+note bottom
+  Scala の IO モナドとは異なり
+  Clojure は実用的なアプローチを取る
+end note
+@enduml
+```
+### 8.3 サイコロを振る例
+**ソースファイル**: `app/clojure/src/ch08/state_management.clj`
+#### 不純な関数（副作用あり）
+```clojure
+(defn cast-the-die-impure!
+  "サイコロを振る（不純）"
+  []
+  (inc (rand-int 6)))
+;; 呼び出すたびに異なる値が返る
+(cast-the-die-impure!) ; => 3
+(cast-the-die-impure!) ; => 5
+(cast-the-die-impure!) ; => 1
+```
+#### delay を使った遅延評価
+```clojure
+(defn cast-the-die
+  "サイコロを振る（遅延）"
+  []
+  (delay (cast-the-die-impure!)))
+;; delay を作成しただけでは実行されない
+(def die-cast (cast-the-die))
+die-cast ; => #<Delay@...>
+;; force で実行
+(force die-cast) ; => 4
+```
+> **注意**: `delay` は一度だけ評価され、結果がキャッシュされます。毎回実行するには新しい `delay` を作成するか、関数でラップします。
+### 8.4 atom による状態管理
+**atom** は Clojure の最も基本的な状態管理プリミティブです。Scala の `Ref` に相当します。
+```plantuml
+@startuml
+!theme plain
+rectangle "atom の操作" {
+  card "atom" as create
+  card "@atom (deref)" as read
+  card "swap!" as swap
+  card "reset!" as reset
+  create --> read : 値を読み取り
+  create --> swap : 関数を適用して更新
+  create --> reset : 値を直接設定
+}
+@enduml
+```
+```clojure
+;; atom を作成
+(def counter (atom 0))
+;; 値を読み取り
+@counter            ; => 0
+(deref counter)     ; => 0
+;; swap! で関数を適用して更新
+(swap! counter inc) ; => 1
+(swap! counter + 5) ; => 6
+;; reset! で値を直接設定
+(reset! counter 0)  ; => 0
+```
+### 8.5 atom の高度な操作
+```clojure
+;; compare-and-set! は期待値と一致する場合のみ更新
+(def a (atom 5))
+(compare-and-set! a 5 10) ; => true, @a = 10
+(compare-and-set! a 5 20) ; => false, @a = 10（変更されない）
+;; 複数の値を持つ atom
+(def game-state (atom {:rolls [] :total 0}))
+(defn roll-die!
+  "サイコロを振って状態を更新"
+  []
+  (let [roll (cast-the-die-impure!)]
+    (swap! game-state
+           (fn [state]
+             (-> state
+                 (update :rolls conj roll)
+                 (update :total + roll))))
+    roll))
+```
+### 8.6 future による非同期処理
+**future** は別スレッドで計算を実行します。
+```clojure
+;; future を作成
+(def f (future
+         (Thread/sleep 1000)
+         (+ 1 2)))
+;; deref で結果を取得（完了まで待機）
+@f ; => 3
+;; タイムアウト付きで取得
+(deref f 500 :timeout) ; => :timeout または結果
+```
+#### 並列 API 呼び出し
+```clojure
+(defn async-api-call
+  "非同期 API 呼び出しをシミュレート"
+  [name delay-ms]
+  (future
+    (Thread/sleep delay-ms)
+    {:name name :result (str "Result for " name)}))
+(defn parallel-api-calls
+  "並列で API を呼び出す"
+  [names]
+  (let [futures (mapv #(async-api-call % 100) names)]
+    (mapv deref futures)))
+(parallel-api-calls ["a" "b" "c"])
+; => [{:name "a" ...} {:name "b" ...} {:name "c" ...}]
+```
+### 8.7 promise による同期
+**promise** は一度だけ値を設定できるコンテナです。
+```clojure
+;; promise を作成
+(def p (promise))
+;; 値を設定
+(deliver p 42)
+;; 値を取得
+@p ; => 42
+;; タイムアウト付き
+(deref p 100 :default) ; => 42 または :default
+```
+### 8.8 ミーティングスケジューリングの例
+```clojure
+(defn meeting-time [start-hour end-hour]
+  {:start-hour start-hour :end-hour end-hour})
+(defn meetings-overlap?
+  "2つのミーティングが重複するか"
+  [m1 m2]
+  (not (or (>= (:start-hour m1) (:end-hour m2))
+           (>= (:start-hour m2) (:end-hour m1)))))
+(defn possible-meetings
+  "空き時間を計算（純粋関数）"
+  [existing-meetings start-hour end-hour length-hours]
+  (let [slots (for [start (range start-hour (- end-hour length-hours -1))]
+                (meeting-time start (+ start length-hours)))]
+    (filter (fn [slot]
+              (not-any? #(meetings-overlap? % slot) existing-meetings))
+            slots)))
+```
+### 8.9 リトライ戦略
+```clojure
+(defn retry
+  "アクションを n 回リトライ"
+  [action max-retries]
+  (loop [attempts 0]
+    (let [result (try
+                   {:ok (action)}
+                   (catch Exception e
+                     {:error (.getMessage e)}))]
+      (if (or (:ok result) (>= attempts max-retries))
+        result
+        (recur (inc attempts))))))
+(defn retry-with-delay
+  "遅延付きでリトライ"
+  [action max-retries delay-ms]
+  (loop [attempts 0]
+    (let [result (try
+                   {:ok (action)}
+                   (catch Exception e
+                     {:error (.getMessage e)}))]
+      (if (or (:ok result) (>= attempts max-retries))
+        result
+        (do
+          (Thread/sleep delay-ms)
+          (recur (inc attempts)))))))
+```
+### 8.10 副作用の分離パターン
+```plantuml
+@startuml
+!theme plain
+rectangle "副作用の分離" {
+  rectangle "純粋なコア" as core {
+    card "calculate-discount"
+    card "calculate-total"
+  }
+  rectangle "副作用を持つシェル" as shell {
+    card "save-order!"
+    card "get-order"
+  }
+  core <-- shell : 使用
+}
+note bottom
+  ビジネスロジックを純粋関数に
+  副作用を境界に押し出す
+end note
+@enduml
+```
+```clojure
+;; 純粋なコアロジック
+(defn calculate-discount [price discount-rate]
+  (* price (- 1 discount-rate)))
+(defn calculate-total [items]
+  (reduce + (map :price items)))
+;; 副作用を持つシェル
+(def order-db (atom {}))
+(defn save-order! [order-id order]
+  (swap! order-db assoc order-id order)
+  order-id)
+;; 副作用を分離した処理
+(defn process-order! [order-id items discount-rate]
+  (let [subtotal (calculate-total items)          ; 純粋
+        total (calculate-discount subtotal discount-rate)]  ; 純粋
+    (save-order! order-id {:items items          ; 副作用
+                           :subtotal subtotal
+                           :total total})))
+```
+---
+## 第9章: 遅延シーケンスとストリーム処理
+### 9.1 遅延シーケンスとは
+Clojure のシーケンスは**遅延評価**されます。要素は必要になるまで計算されません。
+```plantuml
+@startuml
+!theme plain
+rectangle "遅延シーケンス" {
+  card "(range)" as infinite
+  card "(take 5 ...)" as take
+  card "(1 2 3 4 5)" as result
+  infinite --> take : 必要な分だけ
+  take --> result : 実体化
+}
+note bottom
+  無限シーケンスも
+  必要な分だけ計算
+end note
+@enduml
+```
+### 9.2 lazy-seq による遅延シーケンス
+```clojure
+(defn lazy-range
+  "遅延範囲シーケンス"
+  [start end]
+  (lazy-seq
+   (when (< start end)
+     (cons start (lazy-range (inc start) end)))))
+;; range は遅延シーケンス
+(def numbers (range 1 11))
+;; まだ評価されていない
+;; take で必要な分だけ取得
+(take 3 numbers)  ; => (1 2 3)
+```
+### 9.3 無限シーケンス
+Clojure には無限シーケンスを生成する関数があります。
+| 関数 | 説明 | 例 |
+|------|------|-----|
+| `repeat` | 同じ値を無限に繰り返す | `(take 5 (repeat 1))` => `(1 1 1 1 1)` |
+| `iterate` | 関数を繰り返し適用 | `(take 5 (iterate inc 0))` => `(0 1 2 3 4)` |
+| `cycle` | シーケンスを無限に繰り返す | `(take 5 (cycle [1 2]))` => `(1 2 1 2 1)` |
+| `repeatedly` | 関数を無限に呼び出す | `(take 3 (repeatedly rand))` |
+```clojure
+;; 2のべき乗
+(def powers-of-2 (iterate #(* 2 %) 1))
+(take 10 powers-of-2)
+; => (1 2 4 8 16 32 64 128 256 512)
+;; 無限のサイコロ
+(def infinite-die-rolls (repeatedly #(inc (rand-int 6))))
+(take 5 infinite-die-rolls) ; => (3 1 5 2 4)
+```
+### 9.4 遅延シーケンスの操作
+```clojure
+(defn process-stream
+  "ストリームを処理"
+  [stream]
+  (->> stream
+       (filter odd?)
+       (map #(* % %))
+       (take 5)))
+(process-stream (range))
+; => (1 9 25 49 81)
+;; take-while: 条件を満たす間取得
+(take-while pos? [1 2 3 -1 4 5])
+; => (1 2 3)
+;; drop-while: 条件を満たす間スキップ
+(drop-while #(< % 5) [1 2 3 4 5 6 7])
+; => (5 6 7)
+```
+### 9.5 スライディングウィンドウ
+```plantuml
+@startuml
+!theme plain
+rectangle "スライディングウィンドウ" {
+  card "[1 2 3 4 5]" as input
+  card "(partition 3 1 ...)" as part
+  card "((1 2 3) (2 3 4) (3 4 5))" as output
+  input --> part
+  part --> output
+}
+@enduml
+```
+```clojure
+;; partition: 指定サイズで分割
+(partition 3 (range 10))
+; => ((0 1 2) (3 4 5) (6 7 8))
+;; partition-all: 端数も含める
+(partition-all 3 (range 10))
+; => ((0 1 2) (3 4 5) (6 7 8) (9))
+;; partition with step: スライディングウィンドウ
+(defn sliding-window [n coll]
+  (partition n 1 coll))
+(sliding-window 3 [1 2 3 4 5])
+; => ((1 2 3) (2 3 4) (3 4 5))
+```
+### 9.6 トレンド検出
+為替レートの上昇・下降トレンドを検出します。
+```clojure
+(defn trending?
+  "上昇トレンドかどうか"
+  [rates]
+  (and (> (count rates) 1)
+       (every? (fn [[prev curr]] (< prev curr))
+               (partition 2 1 rates))))
+(trending? [0.81 0.82 0.83])  ; => true
+(trending? [0.81 0.84 0.83])  ; => false
+(defn declining?
+  "下降トレンドかどうか"
+  [rates]
+  (and (> (count rates) 1)
+       (every? (fn [[prev curr]] (> prev curr))
+               (partition 2 1 rates))))
+(defn find-trend
+  "トレンドを検出"
+  [window-size stream]
+  (->> stream
+       (sliding-window window-size)
+       (map (fn [window]
+              {:rates (vec window)
+               :trending? (trending? window)
+               :declining? (declining? window)}))))
+```
+### 9.7 reductions（スキャン操作）
+`reductions` は `reduce` の中間結果をすべて返します。Scala の `scanLeft` に相当します。
+```clojure
+;; 累積和
+(reductions + (range 1 6))
+; => (1 3 6 10 15)
+;; 移動平均
+(defn moving-average [window-size coll]
+  (->> coll
+       (sliding-window window-size)
+       (map #(/ (reduce + %) (count %)))))
+(moving-average 3 [1 2 3 4 5 6 7 8 9 10])
+; => (2 3 4 5 6 7 8 9)
+```
+### 9.8 トランスデューサー
+**トランスデューサー**は変換を合成する効率的な方法です。中間コレクションを作らずに処理できます。
+```plantuml
+@startuml
+!theme plain
+rectangle "通常のチェーン" {
+  card "coll" as c1
+  card "filter" as f1
+  card "中間coll" as c2
+  card "map" as m1
+  card "中間coll" as c3
+  card "take" as t1
+  card "結果" as r1
+  c1 --> f1
+  f1 --> c2
+  c2 --> m1
+  m1 --> c3
+  c3 --> t1
+  t1 --> r1
+}
+rectangle "トランスデューサー" {
+  card "coll" as c4
+  card "comp(filter, map, take)" as comp1
+  card "結果" as r2
+  c4 --> comp1
+  comp1 --> r2
+}
+note bottom of comp1
+  中間コレクションなし
+  一度のパスで処理
+end note
+@enduml
+```
+```clojure
+;; トランスデューサーを合成
+(def xform
+  (comp
+   (filter odd?)
+   (map #(* % %))
+   (take 5)))
+;; into で使用
+(into [] xform (range 20))
+; => [1 9 25 49 81]
+;; sequence で遅延処理
+(sequence xform (range 20))
+; => (1 9 25 49 81)
+```
+### 9.9 eduction
+`eduction` はトランスデューサーを使った効率的な遅延処理です。
+```clojure
+(defn efficient-process [coll]
+  (eduction
+   (filter odd?)
+   (map #(* % %))
+   (take 5)
+   coll))
+;; reduce, into, run! などと組み合わせて使用
+(into [] (efficient-process (range 20)))
+; => [1 9 25 49 81]
+```
+### 9.10 実践例：ログストリーム処理
+```clojure
+(def log-levels #{:debug :info :warn :error})
+(defn generate-log-entry []
+  {:timestamp (System/currentTimeMillis)
+   :level (rand-nth (vec log-levels))
+   :message (str "Log message " (rand-int 1000))})
+(def log-stream (repeatedly generate-log-entry))
+(defn filter-errors [logs]
+  (filter #(= :error (:level %)) logs))
+(defn count-by-level [logs]
+  (frequencies (map :level logs)))
+(defn recent-errors [n logs]
+  (->> logs
+       filter-errors
+       (take n)))
+```
+### 9.11 実践例：センサーデータストリーム
+```clojure
+(defn sensor-stream [base-value variance]
+  (repeatedly #(+ base-value (* (- (rand) 0.5) variance))))
+(defn detect-anomalies [threshold stream]
+  (filter #(> (Math/abs (- % 50)) threshold) stream))
+(defn alert-on-anomaly [threshold n stream]
+  (->> stream
+       (detect-anomalies threshold)
+       (take n)
+       (map (fn [value]
+              {:type :anomaly
+               :value value
+               :timestamp (System/currentTimeMillis)}))))
+```
+### 9.12 バッチ処理
+```clojure
+(defn process-in-batches [batch-size process-fn coll]
+  (->> coll
+       (partition-all batch-size)
+       (map process-fn)))
+(defn batch-sum [batch-size coll]
+  (process-in-batches batch-size #(reduce + %) coll))
+(batch-sum 3 [1 2 3 4 5 6 7 8 9 10])
+; => (6 15 24 10)
+```
+### 9.13 パイプライン処理
+```clojure
+(defn pipeline [& fns]
+  (fn [coll]
+    (reduce (fn [acc f] (f acc)) coll fns)))
+(def my-pipeline
+  (pipeline
+   (partial filter odd?)
+   (partial map #(* % 2))
+   (partial take 5)))
+(my-pipeline (range 20))
+; => (2 6 10 14 18)
+```
+---
+## まとめ
+### Clojure vs Scala の比較
+| 概念 | Scala (cats-effect) | Clojure |
+|------|---------------------|---------|
+| 副作用の遅延 | `IO.delay` | `delay` / 関数 |
+| 状態管理 | `Ref[IO, A]` | `atom` |
+| 非同期処理 | `IO.async` | `future` |
+| 同期プリミティブ | `Deferred` | `promise` |
+| ストリーム処理 | fs2 `Stream` | 遅延シーケンス |
+| 変換の合成 | パイプ演算子 | トランスデューサー |
+### 学んだこと
+1. **状態管理**: atom を使った安全な状態管理
+2. **遅延評価**: delay と force による遅延実行
+3. **非同期処理**: future と promise による並行プログラミング
+4. **遅延シーケンス**: 無限シーケンスと遅延評価
+5. **トランスデューサー**: 効率的な変換の合成
+6. **副作用の分離**: 純粋なコアと副作用を持つシェル
+### 次のステップ
+- Part V では、関数型プログラミングの高度なテクニックを学びます
+- Part VI では、実践的なアプリケーション開発を行います