@k2works/claude-code-booster 4.6.0 → 4.7.0

package/lib/assets/docs/article/grokkingfp/haskell/part-4.md

@@ -1,878 +1,878 @@
-# Part IV: IO と副作用の管理
-
-本章では、関数型プログラミングにおける副作用の扱い方を学びます。Haskell では IO モナドを使って副作用を型システムで管理し、遅延リストで無限のデータを扱う方法を習得します。
-
----
-
-## 第8章: IO モナドの導入
-
-### 8.1 副作用の問題
-
-純粋関数は副作用を持ちません。しかし、実際のプログラムには副作用が必要です:
-
-- ファイルの読み書き
-- ネットワーク通信
-- データベースアクセス
-- 乱数生成
-- 現在時刻の取得
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "副作用の問題" {
-  rectangle "副作用を持つ関数" as impure {
-    card "テストが困難"
-    card "予測不可能"
-    card "参照透過性がない"
-  }
-
-  rectangle "純粋関数" as pure {
-    card "テストが容易"
-    card "予測可能"
-    card "参照透過性がある"
-  }
-}
-
-note bottom
-  Haskell では IO 型で
-  副作用を明示的に管理
-end note
-
-@enduml
-```
-
-### 8.2 IO モナドとは
-
-Haskell の **IO モナド**は「副作用を持つ計算」を表す型です。
-
-- `IO a` は「実行すると `a` 型の値を返す副作用のある計算」
-- IO 値は `do` 記法で合成できる
-- Haskell のプログラムは `main :: IO ()` から始まる
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "IO の仕組み" {
-  card "IO アクション定義" as create
-  card "IO a 値" as io
-  card "main 関数" as run
-  card "副作用が実行される" as effect
-
-  create --> io : 計算を記述
-  io --> run : プログラムとして
-  run --> effect : 実際に実行
-}
-
-note bottom of io
-  IO 型は副作用を
-  型システムで追跡
-end note
-
-@enduml
-```
-
-### 8.3 サイコロを振る例
-
-**ソースファイル**: `app/haskell/src/Ch08/IOMonad.hs`
-
-#### 乱数生成（IO を使用）
-
-```haskell
-import System.Random (randomRIO)
-
--- | サイコロを振る（副作用あり）
-castTheDie :: IO Int
-castTheDie = randomRIO (1, 6)
-```
-
-Scala との違い:
-
-
-- Scala: `IO.delay(random.nextInt(6) + 1)` で副作用をラップ
-- Haskell: `randomRIO` 自体が `IO Int` を返す
-
-#### サイコロを2回振る
-
-```haskell
--- | サイコロを2回振って合計を返す
-castTheDieTwice :: IO Int
-castTheDieTwice = do
-    first  <- castTheDie
-    second <- castTheDie
-    return (first + second)
-```
-
-Scala での同等のコード:
-```scala
-def castTheDieTwice(): IO[Int] = {
-  for {
-    first  <- castTheDie()
-    second <- castTheDie()
-  } yield first + second
-}
-```
-
-### 8.4 do 記法
-
-Haskell の `do` 記法は、Scala の `for` 内包表記に相当します。
-
-```haskell
--- do 記法
-castTheDieTwice :: IO Int
-castTheDieTwice = do
-    first  <- castTheDie
-    second <- castTheDie
-    return (first + second)
-
--- 脱糖後（>>=を使用）
-castTheDieTwice :: IO Int
-castTheDieTwice =
-    castTheDie >>= \first ->
-    castTheDie >>= \second ->
-    return (first + second)
-```
-
-| Haskell | Scala | 説明 |
-|---------|-------|------|
-| `do` | `for` | モナド内包表記 |
-| `<-` | `<-` | 値の取り出し |
-| `return` | `yield` または `IO.pure` | 値をモナドに包む |
-| `>>=` | `flatMap` | モナドの連鎖 |
-
-### 8.5 複数回のサイコロ
-
-```haskell
-import Control.Monad (replicateM)
-
--- | サイコロをn回振って結果をリストで返す
-castTheDieN :: Int -> IO [Int]
-castTheDieN n = replicateM n castTheDie
-```
-
-`replicateM` は Scala の `sequence` + `List.fill` に相当:
-```scala
-// Scala
-def castTheDieN(n: Int): IO[List[Int]] =
-  List.fill(n)(castTheDie()).sequence
-```
-
-### 8.6 ミーティングスケジューリングの例
-
-#### データ型の定義
-
-```haskell
--- | ミーティング時間を表すデータ型
-data MeetingTime = MeetingTime
-    { mtStartHour :: Int
-    , mtEndHour   :: Int
-    } deriving (Show, Eq)
-```
-
-#### 重複判定（純粋関数）
-
-```haskell
--- | 2つのミーティングが重なっているかを判定
-meetingsOverlap :: MeetingTime -> MeetingTime -> Bool
-meetingsOverlap m1 m2 =
-    mtStartHour m1 < mtEndHour m2 && mtEndHour m1 > mtStartHour m2
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "ミーティングの重複判定" {
-  card "[9:00-10:00]" as m1
-  card "[10:00-11:00]" as m2
-  card "[9:00-11:00]" as m3
-
-  m1 -[hidden]-> m2
-  m2 -[hidden]-> m3
-}
-
-note "m1 と m2: 重複なし（隣接）" as n1
-note "m1 と m3: 重複あり" as n2
-note "m2 と m3: 重複あり" as n3
-
-@enduml
-```
-
-#### 空き時間の計算
-
-```haskell
--- | 可能なミーティング時間を計算（純粋関数）
-possibleMeetings :: [MeetingTime] -> Int -> Int -> Int -> [MeetingTime]
-possibleMeetings existingMeetings startHour endHour lengthHours =
-    let slots = [MeetingTime s (s + lengthHours) | s <- [startHour .. endHour - lengthHours]]
-    in filter (\slot -> all (not . meetingsOverlap slot) existingMeetings) slots
-```
-
-Haskell のリスト内包表記 `[... | ...]` は、Scala の `for` 内包表記に似ています:
-```scala
-// Scala
-val slots = for {
-  s <- startHour to (endHour - lengthHours)
-} yield MeetingTime(s, s + lengthHours)
-```
-
-### 8.7 IO の合成
-
-```haskell
--- | 2つの IO を合成
-combineIO :: IO a -> IO b -> (a -> b -> c) -> IO c
-combineIO io1 io2 f = do
-    a <- io1
-    b <- io2
-    return (f a b)
-```
-
-使用例:
-```haskell
-ghci> result <- combineIO (return 1) (return 2) (+)
-ghci> print result
-3
-```
-
-#### IO のリストを順番に実行
-
-```haskell
--- | IO のリストを順番に実行
-sequenceIO :: [IO a] -> IO [a]
-sequenceIO []     = return []
-sequenceIO (x:xs) = do
-    a  <- x
-    as <- sequenceIO xs
-    return (a : as)
-```
-
-標準ライブラリの `sequence` と同じ機能です。
-
-### 8.8 エラーハンドリング
-
-```haskell
-import Control.Exception (try, SomeException)
-
--- | 例外をキャッチして Either に変換
-catchIO :: IO a -> IO (Either String a)
-catchIO action = do
-    result <- try action :: IO (Either SomeException a)
-    return $ case result of
-        Right a -> Right a
-        Left e  -> Left (show e)
-```
-
-#### リトライ機能
-
-```haskell
--- | IO アクションをリトライ
-retryIO :: Int -> IO a -> IO (Maybe a)
-retryIO 0 _      = return Nothing
-retryIO n action = do
-    result <- try action :: IO (Either SomeException a)
-    case result of
-        Right a -> return (Just a)
-        Left _  -> retryIO (n - 1) action
-
--- | リトライしてデフォルト値を返す
-retryWithDefault :: Int -> a -> IO a -> IO a
-retryWithDefault maxRetries defaultVal action = do
-    result <- retryIO maxRetries action
-    return $ maybe defaultVal id result
-```
-
-### 8.9 純粋関数と IO の分離
-
-```haskell
--- | 入力をパースして検証（純粋関数）
-parseAndValidate :: String -> Either String Int
-parseAndValidate input =
-    case reads input of
-        [(n, "")] | n > 0     -> Right n
-                  | otherwise -> Left "Number must be positive"
-        _                     -> Left "Invalid number"
-
--- | 入力を処理（IO と純粋関数の分離）
-processInput :: IO ()
-processInput = do
-    putStr "Enter a positive number: "
-    input <- getLine
-    case parseAndValidate input of
-        Right n  -> putStrLn $ "Valid: " ++ show n
-        Left err -> putStrLn $ "Error: " ++ err
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "純粋関数と IO の分離" {
-  card "getLine" as input
-  card "parseAndValidate\n(純粋関数)" as parse
-  card "putStrLn" as output
-
-  input --> parse : String
-  parse --> output : Either String Int
-}
-
-note bottom
-  IO は境界部分のみ
-  ロジックは純粋関数で
-end note
-
-@enduml
-```
-
----
-
-## 第9章: ストリーム処理
-
-### 9.1 遅延リストとは
-
-Haskell のリストは**遅延評価**されます。これにより、無限リストを扱うことができます。
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "List (正格評価) vs Haskell List (遅延評価)" {
-  rectangle "Scala List" as list {
-    card "全要素がメモリに存在"
-    card "有限"
-    card "即座に評価"
-  }
-
-  rectangle "Haskell List" as stream {
-    card "必要な時に要素を生成"
-    card "無限も可能"
-    card "遅延評価"
-  }
-}
-
-@enduml
-```
-
-Scala では `fs2.Stream` を使いますが、Haskell では標準のリストが遅延評価のため、そのまま無限ストリームとして機能します。
-
-### 9.2 無限ストリームの基本
-
-**ソースファイル**: `app/haskell/src/Ch09/StreamProcessing.hs`
-
-```haskell
--- | 自然数の無限ストリーム
-naturals :: [Integer]
-naturals = [1..]
-
--- | 偶数の無限ストリーム
-evens :: [Integer]
-evens = [2,4..]
-
--- | 奇数の無限ストリーム
-odds :: [Integer]
-odds = [1,3..]
-```
-
-```haskell
-ghci> take 10 naturals
-[1,2,3,4,5,6,7,8,9,10]
-
-ghci> take 5 evens
-[2,4,6,8,10]
-```
-
-### 9.3 フィボナッチ数列
-
-遅延評価を使った自己参照的な定義:
-
-```haskell
--- | フィボナッチ数列の無限ストリーム
-fibs :: [Integer]
-fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "フィボナッチ数列の生成" {
-  card "fibs     = [0, 1, 1, 2, 3, 5, 8, ...]" as f1
-  card "tail fibs = [1, 1, 2, 3, 5, 8, ...]" as f2
-  card "zipWith (+)" as zip
-  card "[1, 2, 3, 5, 8, 13, ...]" as result
-
-  f1 --> zip
-  f2 --> zip
-  zip --> result
-}
-
-note bottom
-  自己参照的な定義
-  遅延評価で可能に
-end note
-
-@enduml
-```
-
-```haskell
-ghci> take 10 fibs
-[0,1,1,2,3,5,8,13,21,34]
-```
-
-### 9.4 素数のストリーム（エラトステネスのふるい）
-
-```haskell
--- | 素数の無限ストリーム
-primes :: [Integer]
-primes = sieve [2..]
-  where
-    sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]
-    sieve []     = []
-```
-
-```haskell
-ghci> take 10 primes
-[2,3,5,7,11,13,17,19,23,29]
-```
-
-### 9.5 ストリーム生成関数
-
-```haskell
--- | 同じ値を無限に繰り返す（Scala の Stream.repeat に相当）
-repeatVal :: a -> [a]
-repeatVal x = x : repeatVal x
-
--- | リストを無限に繰り返す（Scala の Stream(...).repeat に相当）
-cycleList :: [a] -> [a]
-cycleList xs = xs ++ cycleList xs
-
--- | 関数を繰り返し適用して無限リストを生成
-iterate' :: (a -> a) -> a -> [a]
-iterate' f x = x : iterate' f (f x)
-```
-
-```haskell
-ghci> take 5 (repeatVal 1)
-[1,1,1,1,1]
-
-ghci> take 7 (cycleList [1,2,3])
-[1,2,3,1,2,3,1]
-
-ghci> take 5 (iterate' (*2) 1)
-[1,2,4,8,16]
-```
-
-### 9.6 unfold: 汎用的なストリーム生成
-
-```haskell
--- | unfold: 種から無限リストを生成
-unfold :: (b -> Maybe (a, b)) -> b -> [a]
-unfold f seed = case f seed of
-    Nothing      -> []
-    Just (a, b') -> a : unfold f b'
-```
-
-Scala の `Stream.unfold` に相当:
-```scala
-// Scala
-Stream.unfold(0)(n => Some((n, n + 1)))
-```
-
-```haskell
--- Haskell
-ghci> take 5 (unfold (\n -> Just (n, n+1)) 0)
-[0,1,2,3,4]
-```
-
-### 9.7 ストリーム操作
-
-```haskell
--- | 条件を満たす間、要素を取得（Scala の takeWhile）
-takeWhile' :: (a -> Bool) -> [a] -> [a]
-takeWhile' _ []     = []
-takeWhile' p (x:xs)
-    | p x       = x : takeWhile' p xs
-    | otherwise = []
-
--- | 条件を満たす間、要素をスキップ（Scala の dropWhile）
-dropWhile' :: (a -> Bool) -> [a] -> [a]
-dropWhile' _ []     = []
-dropWhile' p xs@(x:xs')
-    | p x       = dropWhile' p xs'
-    | otherwise = xs
-```
-
-```haskell
-ghci> takeWhile' (<5) [1,2,3,4,5,6]
-[1,2,3,4]
-
-ghci> dropWhile' (<5) [1,2,3,4,5,6]
-[5,6]
-```
-
-### 9.8 スライディングウィンドウ
-
-```haskell
--- | スライディングウィンドウ（Scala の sliding に相当）
-sliding :: Int -> [a] -> [[a]]
-sliding n xs
-    | length window < n = []
-    | otherwise         = window : sliding n (tail xs)
-  where
-    window = take n xs
-```
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "sliding 3 [1,2,3,4,5] の動作" {
-  card "[1, 2, 3, 4, 5]" as input
-  card "[1, 2, 3]" as w1
-  card "[2, 3, 4]" as w2
-  card "[3, 4, 5]" as w3
-
-  input --> w1
-  input --> w2
-  input --> w3
-}
-
-@enduml
-```
-
-```haskell
-ghci> sliding 3 [1,2,3,4,5]
-[[1,2,3],[2,3,4],[3,4,5]]
-```
-
-### 9.9 チャンク分割
-
-```haskell
--- | 固定サイズのチャンクに分割
-chunksOf :: Int -> [a] -> [[a]]
-chunksOf _ [] = []
-chunksOf n xs = take n xs : chunksOf n (drop n xs)
-```
-
-```haskell
-ghci> chunksOf 3 [1,2,3,4,5,6,7,8]
-[[1,2,3],[4,5,6],[7,8]]
-```
-
-### 9.10 トレンド検出
-
-通貨交換レートの監視に使用する関数:
-
-```haskell
--- | 上昇トレンドかどうかを判定
-trending :: Ord a => [a] -> Bool
-trending xs =
-    length xs > 1 &&
-    all (uncurry (<)) (zip xs (tail xs))
-
--- | 安定（全て同じ値）かどうかを判定
-isStable :: Eq a => [a] -> Bool
-isStable xs =
-    length xs >= 3 &&
-    all (== head xs) xs
-```
-
-```haskell
-ghci> trending [0.81, 0.82, 0.83]
-True
-
-ghci> trending [0.81, 0.84, 0.83]
-False
-
-ghci> isStable [5, 5, 5]
-True
-```
-
-### 9.11 通貨交換レートの例
-
-```haskell
-type ExchangeRate = Double
-
--- | 為替レートをシミュレート（無限ストリーム）
-simulateRates :: ExchangeRate -> [ExchangeRate]
-simulateRates initial = iterate' vary initial
-  where
-    vary rate = rate + sin (rate * 100) * 0.01
-
--- | 上昇トレンドを検出するまでレートを監視
-findUptrend :: Int -> [ExchangeRate] -> Maybe [ExchangeRate]
-findUptrend = findTrend
-
--- | ストリームから上昇トレンドを検出
-findTrend :: Ord a => Int -> [a] -> Maybe [a]
-findTrend windowSize xs =
-    case filter trending (sliding windowSize xs) of
-        []    -> Nothing
-        (w:_) -> Just w
-```
-
-#### トレンドを検出して交換
-
-```haskell
--- | 上昇トレンドを検出したら交換
-exchangeIfTrending :: Double -> Int -> [ExchangeRate] -> Maybe Double
-exchangeIfTrending amount windowSize rates =
-    case findUptrend windowSize rates of
-        Just trend -> Just $ amount * last trend
-        Nothing    -> Nothing
-```
-
-```haskell
-ghci> exchangeIfTrending 100 3 [0.80, 0.81, 0.82, 0.83, 0.80]
-Just 82.0
-```
-
-### 9.12 ストリーム合成
-
-```haskell
--- | インデックス付きストリーム（Scala の zipWithIndex）
-zipWithIndex :: [a] -> [(Int, a)]
-zipWithIndex = zip [0..]
-
--- | 2つのストリームを交互に合成
-interleave :: [a] -> [a] -> [a]
-interleave []     ys     = ys
-interleave xs     []     = xs
-interleave (x:xs) (y:ys) = x : y : interleave xs ys
-
--- | 2つのソート済みストリームをマージ
-merge :: Ord a => [a] -> [a] -> [a]
-merge []     ys     = ys
-merge xs     []     = xs
-merge (x:xs) (y:ys)
-    | x <= y    = x : merge xs (y:ys)
-    | otherwise = y : merge (x:xs) ys
-```
-
-```haskell
-ghci> take 3 (zipWithIndex ['a', 'b', 'c'])
-[(0,'a'),(1,'b'),(2,'c')]
-
-ghci> take 6 (interleave [1,3,5] [2,4,6])
-[1,2,3,4,5,6]
-
-ghci> take 10 (merge [1,3,5,7,9] [2,4,6,8,10])
-[1,2,3,4,5,6,7,8,9,10]
-```
-
----
-
-## まとめ
-
-### Part IV で学んだこと
-
-```plantuml
-@startuml
-!theme plain
-
-rectangle "Part IV: IO と副作用の管理" {
-  rectangle "第8章" as ch8 {
-    card "IO モナド"
-    card "do 記法"
-    card "replicateM"
-    card "try / catch"
-    card "retryIO"
-    card "純粋関数との分離"
-  }
-
-  rectangle "第9章" as ch9 {
-    card "遅延リスト"
-    card "無限ストリーム"
-    card "iterate / unfold"
-    card "sliding"
-    card "zipWithIndex"
-    card "interleave / merge"
-  }
-}
-
-ch8 --> ch9
-
-@enduml
-```
-
-### Scala と Haskell の比較
-
-| 概念 | Scala (cats-effect/fs2) | Haskell |
-|------|-------------------------|---------|
-| 副作用の型 | `IO[A]` | `IO a` |
-| 遅延実行 | `IO.delay(expr)` | 関数が `IO` を返す |
-| 値のラップ | `IO.pure(value)` | `return value` |
-| モナド合成 | `for` 内包表記 | `do` 記法 |
-| flatMap | `flatMap` | `>>=` |
-| ストリーム | `fs2.Stream[IO, A]` | 標準の `[a]`（遅延評価） |
-| 無限繰り返し | `Stream(...).repeat` | `repeat` / `cycle` |
-| スライディング | `stream.sliding(n)` | `sliding n xs` |
-| リストの sequence | `list.sequence` | `sequence` |
-
-### キーポイント
-
-1. **IO モナド**: Haskell では副作用を持つ計算は必ず `IO` 型を返す
-2. **do 記法**: Scala の `for` 内包表記に相当、モナドを順序付けて合成
-3. **遅延評価**: Haskell のリストはデフォルトで遅延評価、無限リストが自然に扱える
-4. **純粋関数との分離**: ロジックは純粋関数で、IO は境界部分のみ
-5. **ストリーム生成**: `iterate`、`unfold` で無限ストリームを生成
-6. **パターン検出**: `sliding` でウィンドウを作り、`trending` でパターンを検出
-
-### 次のステップ
-
-Part V では、以下のトピックを学びます:
-
-- 並行・並列処理
-- Concurrent Haskell
-- STM（Software Transactional Memory）
-- async ライブラリ
-
----
-
-## 演習問題
-
-### 問題 1: IO の基本
-
-以下の関数を実装してください。
-
-```haskell
--- メッセージを出力して返す
-printAndReturn :: String -> IO String
-printAndReturn message = ???
-
--- 期待される動作
--- > result <- printAndReturn "Hello"
--- Hello
--- > result
--- "Hello"
-```
-
-<details>
-<summary>解答</summary>
-
-```haskell
-printAndReturn :: String -> IO String
-printAndReturn message = do
-    putStrLn message
-    return message
-```
-
-</details>
-
-### 問題 2: IO の合成
-
-以下の関数を実装してください。2つの IO を順番に実行し、結果を結合します。
-
-```haskell
-combineIO :: IO a -> IO b -> (a -> b -> c) -> IO c
-combineIO io1 io2 f = ???
-
--- 期待される動作
--- > result <- combineIO (return 1) (return 2) (+)
--- > result
--- 3
-```
-
-<details>
-<summary>解答</summary>
-
-```haskell
-combineIO :: IO a -> IO b -> (a -> b -> c) -> IO c
-combineIO io1 io2 f = do
-    a <- io1
-    b <- io2
-    return (f a b)
-```
-
-</details>
-
-### 問題 3: リトライ
-
-以下の関数を実装してください。指定回数リトライし、全部失敗したらデフォルト値を返します。
-
-```haskell
-retryWithDefault :: Int -> a -> IO a -> IO a
-retryWithDefault maxRetries defaultVal action = ???
-```
-
-<details>
-<summary>解答</summary>
-
-```haskell
-import Control.Exception (try, SomeException)
-
-retryWithDefault :: Int -> a -> IO a -> IO a
-retryWithDefault 0 defaultVal _ = return defaultVal
-retryWithDefault n defaultVal action = do
-    result <- try action :: IO (Either SomeException a)
-    case result of
-        Right a -> return a
-        Left _  -> retryWithDefault (n - 1) defaultVal action
-```
-
-</details>
-
-### 問題 4: ストリーム操作
-
-以下のストリームを作成してください。
-
-```haskell
--- 1. 1から10までの偶数のリスト
-evens :: [Int]
-evens = ???
-
--- 2. 無限に交互に True/False を返すリスト
-alternating :: [Bool]
-alternating = ???
-
--- 3. 最初の5つの要素の合計を計算
-sumFirst5 :: [Int] -> Int
-sumFirst5 xs = ???
-```
-
-<details>
-<summary>解答</summary>
-
-```haskell
--- 1. 1から10までの偶数
-evens :: [Int]
-evens = [2, 4, 6, 8, 10]
--- または
-evens = filter even [1..10]
-
--- 2. 無限に交互に True/False
-alternating :: [Bool]
-alternating = cycle [True, False]
-
--- 3. 最初の5つの要素の合計
-sumFirst5 :: [Int] -> Int
-sumFirst5 xs = sum (take 5 xs)
-```
-
-</details>
-
-### 問題 5: トレンド検出
-
-以下の関数を実装してください。直近の値が減少傾向かどうかを判定します。
-
-```haskell
-declining :: Ord a => [a] -> Bool
-declining xs = ???
-
--- 期待される動作
--- declining [0.83, 0.82, 0.81]  -- True (減少トレンド)
--- declining [0.81, 0.82, 0.83]  -- False
--- declining [0.81]              -- False (1要素では判定不可)
-```
-
-<details>
-<summary>解答</summary>
-
-```haskell
-declining :: Ord a => [a] -> Bool
-declining xs =
-    length xs > 1 &&
-    all (uncurry (>)) (zip xs (tail xs))
-```
-
-</details>
+# Part IV: IO と副作用の管理
+
+本章では、関数型プログラミングにおける副作用の扱い方を学びます。Haskell では IO モナドを使って副作用を型システムで管理し、遅延リストで無限のデータを扱う方法を習得します。
+
+---
+
+## 第8章: IO モナドの導入
+
+### 8.1 副作用の問題
+
+純粋関数は副作用を持ちません。しかし、実際のプログラムには副作用が必要です:
+
+- ファイルの読み書き
+- ネットワーク通信
+- データベースアクセス
+- 乱数生成
+- 現在時刻の取得
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "副作用の問題" {
+  rectangle "副作用を持つ関数" as impure {
+    card "テストが困難"
+    card "予測不可能"
+    card "参照透過性がない"
+  }
+
+  rectangle "純粋関数" as pure {
+    card "テストが容易"
+    card "予測可能"
+    card "参照透過性がある"
+  }
+}
+
+note bottom
+  Haskell では IO 型で
+  副作用を明示的に管理
+end note
+
+@enduml
+```
+
+### 8.2 IO モナドとは
+
+Haskell の **IO モナド**は「副作用を持つ計算」を表す型です。
+
+- `IO a` は「実行すると `a` 型の値を返す副作用のある計算」
+- IO 値は `do` 記法で合成できる
+- Haskell のプログラムは `main :: IO ()` から始まる
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "IO の仕組み" {
+  card "IO アクション定義" as create
+  card "IO a 値" as io
+  card "main 関数" as run
+  card "副作用が実行される" as effect
+
+  create --> io : 計算を記述
+  io --> run : プログラムとして
+  run --> effect : 実際に実行
+}
+
+note bottom of io
+  IO 型は副作用を
+  型システムで追跡
+end note
+
+@enduml
+```
+
+### 8.3 サイコロを振る例
+
+**ソースファイル**: `app/haskell/src/Ch08/IOMonad.hs`
+
+#### 乱数生成（IO を使用）
+
+```haskell
+import System.Random (randomRIO)
+
+-- | サイコロを振る（副作用あり）
+castTheDie :: IO Int
+castTheDie = randomRIO (1, 6)
+```
+
+Scala との違い:
+
+
+- Scala: `IO.delay(random.nextInt(6) + 1)` で副作用をラップ
+- Haskell: `randomRIO` 自体が `IO Int` を返す
+
+#### サイコロを2回振る
+
+```haskell
+-- | サイコロを2回振って合計を返す
+castTheDieTwice :: IO Int
+castTheDieTwice = do
+    first  <- castTheDie
+    second <- castTheDie
+    return (first + second)
+```
+
+Scala での同等のコード:
+```scala
+def castTheDieTwice(): IO[Int] = {
+  for {
+    first  <- castTheDie()
+    second <- castTheDie()
+  } yield first + second
+}
+```
+
+### 8.4 do 記法
+
+Haskell の `do` 記法は、Scala の `for` 内包表記に相当します。
+
+```haskell
+-- do 記法
+castTheDieTwice :: IO Int
+castTheDieTwice = do
+    first  <- castTheDie
+    second <- castTheDie
+    return (first + second)
+
+-- 脱糖後（>>=を使用）
+castTheDieTwice :: IO Int
+castTheDieTwice =
+    castTheDie >>= \first ->
+    castTheDie >>= \second ->
+    return (first + second)
+```
+
+| Haskell | Scala | 説明 |
+|---------|-------|------|
+| `do` | `for` | モナド内包表記 |
+| `<-` | `<-` | 値の取り出し |
+| `return` | `yield` または `IO.pure` | 値をモナドに包む |
+| `>>=` | `flatMap` | モナドの連鎖 |
+
+### 8.5 複数回のサイコロ
+
+```haskell
+import Control.Monad (replicateM)
+
+-- | サイコロをn回振って結果をリストで返す
+castTheDieN :: Int -> IO [Int]
+castTheDieN n = replicateM n castTheDie
+```
+
+`replicateM` は Scala の `sequence` + `List.fill` に相当:
+```scala
+// Scala
+def castTheDieN(n: Int): IO[List[Int]] =
+  List.fill(n)(castTheDie()).sequence
+```
+
+### 8.6 ミーティングスケジューリングの例
+
+#### データ型の定義
+
+```haskell
+-- | ミーティング時間を表すデータ型
+data MeetingTime = MeetingTime
+    { mtStartHour :: Int
+    , mtEndHour   :: Int
+    } deriving (Show, Eq)
+```
+
+#### 重複判定（純粋関数）
+
+```haskell
+-- | 2つのミーティングが重なっているかを判定
+meetingsOverlap :: MeetingTime -> MeetingTime -> Bool
+meetingsOverlap m1 m2 =
+    mtStartHour m1 < mtEndHour m2 && mtEndHour m1 > mtStartHour m2
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "ミーティングの重複判定" {
+  card "[9:00-10:00]" as m1
+  card "[10:00-11:00]" as m2
+  card "[9:00-11:00]" as m3
+
+  m1 -[hidden]-> m2
+  m2 -[hidden]-> m3
+}
+
+note "m1 と m2: 重複なし（隣接）" as n1
+note "m1 と m3: 重複あり" as n2
+note "m2 と m3: 重複あり" as n3
+
+@enduml
+```
+
+#### 空き時間の計算
+
+```haskell
+-- | 可能なミーティング時間を計算（純粋関数）
+possibleMeetings :: [MeetingTime] -> Int -> Int -> Int -> [MeetingTime]
+possibleMeetings existingMeetings startHour endHour lengthHours =
+    let slots = [MeetingTime s (s + lengthHours) | s <- [startHour .. endHour - lengthHours]]
+    in filter (\slot -> all (not . meetingsOverlap slot) existingMeetings) slots
+```
+
+Haskell のリスト内包表記 `[... | ...]` は、Scala の `for` 内包表記に似ています:
+```scala
+// Scala
+val slots = for {
+  s <- startHour to (endHour - lengthHours)
+} yield MeetingTime(s, s + lengthHours)
+```
+
+### 8.7 IO の合成
+
+```haskell
+-- | 2つの IO を合成
+combineIO :: IO a -> IO b -> (a -> b -> c) -> IO c
+combineIO io1 io2 f = do
+    a <- io1
+    b <- io2
+    return (f a b)
+```
+
+使用例:
+```haskell
+ghci> result <- combineIO (return 1) (return 2) (+)
+ghci> print result
+3
+```
+
+#### IO のリストを順番に実行
+
+```haskell
+-- | IO のリストを順番に実行
+sequenceIO :: [IO a] -> IO [a]
+sequenceIO []     = return []
+sequenceIO (x:xs) = do
+    a  <- x
+    as <- sequenceIO xs
+    return (a : as)
+```
+
+標準ライブラリの `sequence` と同じ機能です。
+
+### 8.8 エラーハンドリング
+
+```haskell
+import Control.Exception (try, SomeException)
+
+-- | 例外をキャッチして Either に変換
+catchIO :: IO a -> IO (Either String a)
+catchIO action = do
+    result <- try action :: IO (Either SomeException a)
+    return $ case result of
+        Right a -> Right a
+        Left e  -> Left (show e)
+```
+
+#### リトライ機能
+
+```haskell
+-- | IO アクションをリトライ
+retryIO :: Int -> IO a -> IO (Maybe a)
+retryIO 0 _      = return Nothing
+retryIO n action = do
+    result <- try action :: IO (Either SomeException a)
+    case result of
+        Right a -> return (Just a)
+        Left _  -> retryIO (n - 1) action
+
+-- | リトライしてデフォルト値を返す
+retryWithDefault :: Int -> a -> IO a -> IO a
+retryWithDefault maxRetries defaultVal action = do
+    result <- retryIO maxRetries action
+    return $ maybe defaultVal id result
+```
+
+### 8.9 純粋関数と IO の分離
+
+```haskell
+-- | 入力をパースして検証（純粋関数）
+parseAndValidate :: String -> Either String Int
+parseAndValidate input =
+    case reads input of
+        [(n, "")] | n > 0     -> Right n
+                  | otherwise -> Left "Number must be positive"
+        _                     -> Left "Invalid number"
+
+-- | 入力を処理（IO と純粋関数の分離）
+processInput :: IO ()
+processInput = do
+    putStr "Enter a positive number: "
+    input <- getLine
+    case parseAndValidate input of
+        Right n  -> putStrLn $ "Valid: " ++ show n
+        Left err -> putStrLn $ "Error: " ++ err
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "純粋関数と IO の分離" {
+  card "getLine" as input
+  card "parseAndValidate\n(純粋関数)" as parse
+  card "putStrLn" as output
+
+  input --> parse : String
+  parse --> output : Either String Int
+}
+
+note bottom
+  IO は境界部分のみ
+  ロジックは純粋関数で
+end note
+
+@enduml
+```
+
+---
+
+## 第9章: ストリーム処理
+
+### 9.1 遅延リストとは
+
+Haskell のリストは**遅延評価**されます。これにより、無限リストを扱うことができます。
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "List (正格評価) vs Haskell List (遅延評価)" {
+  rectangle "Scala List" as list {
+    card "全要素がメモリに存在"
+    card "有限"
+    card "即座に評価"
+  }
+
+  rectangle "Haskell List" as stream {
+    card "必要な時に要素を生成"
+    card "無限も可能"
+    card "遅延評価"
+  }
+}
+
+@enduml
+```
+
+Scala では `fs2.Stream` を使いますが、Haskell では標準のリストが遅延評価のため、そのまま無限ストリームとして機能します。
+
+### 9.2 無限ストリームの基本
+
+**ソースファイル**: `app/haskell/src/Ch09/StreamProcessing.hs`
+
+```haskell
+-- | 自然数の無限ストリーム
+naturals :: [Integer]
+naturals = [1..]
+
+-- | 偶数の無限ストリーム
+evens :: [Integer]
+evens = [2,4..]
+
+-- | 奇数の無限ストリーム
+odds :: [Integer]
+odds = [1,3..]
+```
+
+```haskell
+ghci> take 10 naturals
+[1,2,3,4,5,6,7,8,9,10]
+
+ghci> take 5 evens
+[2,4,6,8,10]
+```
+
+### 9.3 フィボナッチ数列
+
+遅延評価を使った自己参照的な定義:
+
+```haskell
+-- | フィボナッチ数列の無限ストリーム
+fibs :: [Integer]
+fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "フィボナッチ数列の生成" {
+  card "fibs     = [0, 1, 1, 2, 3, 5, 8, ...]" as f1
+  card "tail fibs = [1, 1, 2, 3, 5, 8, ...]" as f2
+  card "zipWith (+)" as zip
+  card "[1, 2, 3, 5, 8, 13, ...]" as result
+
+  f1 --> zip
+  f2 --> zip
+  zip --> result
+}
+
+note bottom
+  自己参照的な定義
+  遅延評価で可能に
+end note
+
+@enduml
+```
+
+```haskell
+ghci> take 10 fibs
+[0,1,1,2,3,5,8,13,21,34]
+```
+
+### 9.4 素数のストリーム（エラトステネスのふるい）
+
+```haskell
+-- | 素数の無限ストリーム
+primes :: [Integer]
+primes = sieve [2..]
+  where
+    sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p /= 0]
+    sieve []     = []
+```
+
+```haskell
+ghci> take 10 primes
+[2,3,5,7,11,13,17,19,23,29]
+```
+
+### 9.5 ストリーム生成関数
+
+```haskell
+-- | 同じ値を無限に繰り返す（Scala の Stream.repeat に相当）
+repeatVal :: a -> [a]
+repeatVal x = x : repeatVal x
+
+-- | リストを無限に繰り返す（Scala の Stream(...).repeat に相当）
+cycleList :: [a] -> [a]
+cycleList xs = xs ++ cycleList xs
+
+-- | 関数を繰り返し適用して無限リストを生成
+iterate' :: (a -> a) -> a -> [a]
+iterate' f x = x : iterate' f (f x)
+```
+
+```haskell
+ghci> take 5 (repeatVal 1)
+[1,1,1,1,1]
+
+ghci> take 7 (cycleList [1,2,3])
+[1,2,3,1,2,3,1]
+
+ghci> take 5 (iterate' (*2) 1)
+[1,2,4,8,16]
+```
+
+### 9.6 unfold: 汎用的なストリーム生成
+
+```haskell
+-- | unfold: 種から無限リストを生成
+unfold :: (b -> Maybe (a, b)) -> b -> [a]
+unfold f seed = case f seed of
+    Nothing      -> []
+    Just (a, b') -> a : unfold f b'
+```
+
+Scala の `Stream.unfold` に相当:
+```scala
+// Scala
+Stream.unfold(0)(n => Some((n, n + 1)))
+```
+
+```haskell
+-- Haskell
+ghci> take 5 (unfold (\n -> Just (n, n+1)) 0)
+[0,1,2,3,4]
+```
+
+### 9.7 ストリーム操作
+
+```haskell
+-- | 条件を満たす間、要素を取得（Scala の takeWhile）
+takeWhile' :: (a -> Bool) -> [a] -> [a]
+takeWhile' _ []     = []
+takeWhile' p (x:xs)
+    | p x       = x : takeWhile' p xs
+    | otherwise = []
+
+-- | 条件を満たす間、要素をスキップ（Scala の dropWhile）
+dropWhile' :: (a -> Bool) -> [a] -> [a]
+dropWhile' _ []     = []
+dropWhile' p xs@(x:xs')
+    | p x       = dropWhile' p xs'
+    | otherwise = xs
+```
+
+```haskell
+ghci> takeWhile' (<5) [1,2,3,4,5,6]
+[1,2,3,4]
+
+ghci> dropWhile' (<5) [1,2,3,4,5,6]
+[5,6]
+```
+
+### 9.8 スライディングウィンドウ
+
+```haskell
+-- | スライディングウィンドウ（Scala の sliding に相当）
+sliding :: Int -> [a] -> [[a]]
+sliding n xs
+    | length window < n = []
+    | otherwise         = window : sliding n (tail xs)
+  where
+    window = take n xs
+```
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "sliding 3 [1,2,3,4,5] の動作" {
+  card "[1, 2, 3, 4, 5]" as input
+  card "[1, 2, 3]" as w1
+  card "[2, 3, 4]" as w2
+  card "[3, 4, 5]" as w3
+
+  input --> w1
+  input --> w2
+  input --> w3
+}
+
+@enduml
+```
+
+```haskell
+ghci> sliding 3 [1,2,3,4,5]
+[[1,2,3],[2,3,4],[3,4,5]]
+```
+
+### 9.9 チャンク分割
+
+```haskell
+-- | 固定サイズのチャンクに分割
+chunksOf :: Int -> [a] -> [[a]]
+chunksOf _ [] = []
+chunksOf n xs = take n xs : chunksOf n (drop n xs)
+```
+
+```haskell
+ghci> chunksOf 3 [1,2,3,4,5,6,7,8]
+[[1,2,3],[4,5,6],[7,8]]
+```
+
+### 9.10 トレンド検出
+
+通貨交換レートの監視に使用する関数:
+
+```haskell
+-- | 上昇トレンドかどうかを判定
+trending :: Ord a => [a] -> Bool
+trending xs =
+    length xs > 1 &&
+    all (uncurry (<)) (zip xs (tail xs))
+
+-- | 安定（全て同じ値）かどうかを判定
+isStable :: Eq a => [a] -> Bool
+isStable xs =
+    length xs >= 3 &&
+    all (== head xs) xs
+```
+
+```haskell
+ghci> trending [0.81, 0.82, 0.83]
+True
+
+ghci> trending [0.81, 0.84, 0.83]
+False
+
+ghci> isStable [5, 5, 5]
+True
+```
+
+### 9.11 通貨交換レートの例
+
+```haskell
+type ExchangeRate = Double
+
+-- | 為替レートをシミュレート（無限ストリーム）
+simulateRates :: ExchangeRate -> [ExchangeRate]
+simulateRates initial = iterate' vary initial
+  where
+    vary rate = rate + sin (rate * 100) * 0.01
+
+-- | 上昇トレンドを検出するまでレートを監視
+findUptrend :: Int -> [ExchangeRate] -> Maybe [ExchangeRate]
+findUptrend = findTrend
+
+-- | ストリームから上昇トレンドを検出
+findTrend :: Ord a => Int -> [a] -> Maybe [a]
+findTrend windowSize xs =
+    case filter trending (sliding windowSize xs) of
+        []    -> Nothing
+        (w:_) -> Just w
+```
+
+#### トレンドを検出して交換
+
+```haskell
+-- | 上昇トレンドを検出したら交換
+exchangeIfTrending :: Double -> Int -> [ExchangeRate] -> Maybe Double
+exchangeIfTrending amount windowSize rates =
+    case findUptrend windowSize rates of
+        Just trend -> Just $ amount * last trend
+        Nothing    -> Nothing
+```
+
+```haskell
+ghci> exchangeIfTrending 100 3 [0.80, 0.81, 0.82, 0.83, 0.80]
+Just 82.0
+```
+
+### 9.12 ストリーム合成
+
+```haskell
+-- | インデックス付きストリーム（Scala の zipWithIndex）
+zipWithIndex :: [a] -> [(Int, a)]
+zipWithIndex = zip [0..]
+
+-- | 2つのストリームを交互に合成
+interleave :: [a] -> [a] -> [a]
+interleave []     ys     = ys
+interleave xs     []     = xs
+interleave (x:xs) (y:ys) = x : y : interleave xs ys
+
+-- | 2つのソート済みストリームをマージ
+merge :: Ord a => [a] -> [a] -> [a]
+merge []     ys     = ys
+merge xs     []     = xs
+merge (x:xs) (y:ys)
+    | x <= y    = x : merge xs (y:ys)
+    | otherwise = y : merge (x:xs) ys
+```
+
+```haskell
+ghci> take 3 (zipWithIndex ['a', 'b', 'c'])
+[(0,'a'),(1,'b'),(2,'c')]
+
+ghci> take 6 (interleave [1,3,5] [2,4,6])
+[1,2,3,4,5,6]
+
+ghci> take 10 (merge [1,3,5,7,9] [2,4,6,8,10])
+[1,2,3,4,5,6,7,8,9,10]
+```
+
+---
+
+## まとめ
+
+### Part IV で学んだこと
+
+```plantuml
+@startuml
+!theme plain
+
+rectangle "Part IV: IO と副作用の管理" {
+  rectangle "第8章" as ch8 {
+    card "IO モナド"
+    card "do 記法"
+    card "replicateM"
+    card "try / catch"
+    card "retryIO"
+    card "純粋関数との分離"
+  }
+
+  rectangle "第9章" as ch9 {
+    card "遅延リスト"
+    card "無限ストリーム"
+    card "iterate / unfold"
+    card "sliding"
+    card "zipWithIndex"
+    card "interleave / merge"
+  }
+}
+
+ch8 --> ch9
+
+@enduml
+```
+
+### Scala と Haskell の比較
+
+| 概念 | Scala (cats-effect/fs2) | Haskell |
+|------|-------------------------|---------|
+| 副作用の型 | `IO[A]` | `IO a` |
+| 遅延実行 | `IO.delay(expr)` | 関数が `IO` を返す |
+| 値のラップ | `IO.pure(value)` | `return value` |
+| モナド合成 | `for` 内包表記 | `do` 記法 |
+| flatMap | `flatMap` | `>>=` |
+| ストリーム | `fs2.Stream[IO, A]` | 標準の `[a]`（遅延評価） |
+| 無限繰り返し | `Stream(...).repeat` | `repeat` / `cycle` |
+| スライディング | `stream.sliding(n)` | `sliding n xs` |
+| リストの sequence | `list.sequence` | `sequence` |
+
+### キーポイント
+
+1. **IO モナド**: Haskell では副作用を持つ計算は必ず `IO` 型を返す
+2. **do 記法**: Scala の `for` 内包表記に相当、モナドを順序付けて合成
+3. **遅延評価**: Haskell のリストはデフォルトで遅延評価、無限リストが自然に扱える
+4. **純粋関数との分離**: ロジックは純粋関数で、IO は境界部分のみ
+5. **ストリーム生成**: `iterate`、`unfold` で無限ストリームを生成
+6. **パターン検出**: `sliding` でウィンドウを作り、`trending` でパターンを検出
+
+### 次のステップ
+
+Part V では、以下のトピックを学びます:
+
+- 並行・並列処理
+- Concurrent Haskell
+- STM（Software Transactional Memory）
+- async ライブラリ
+
+---
+
+## 演習問題
+
+### 問題 1: IO の基本
+
+以下の関数を実装してください。
+
+```haskell
+-- メッセージを出力して返す
+printAndReturn :: String -> IO String
+printAndReturn message = ???
+
+-- 期待される動作
+-- > result <- printAndReturn "Hello"
+-- Hello
+-- > result
+-- "Hello"
+```
+
+<details>
+<summary>解答</summary>
+
+```haskell
+printAndReturn :: String -> IO String
+printAndReturn message = do
+    putStrLn message
+    return message
+```
+
+</details>
+
+### 問題 2: IO の合成
+
+以下の関数を実装してください。2つの IO を順番に実行し、結果を結合します。
+
+```haskell
+combineIO :: IO a -> IO b -> (a -> b -> c) -> IO c
+combineIO io1 io2 f = ???
+
+-- 期待される動作
+-- > result <- combineIO (return 1) (return 2) (+)
+-- > result
+-- 3
+```
+
+<details>
+<summary>解答</summary>
+
+```haskell
+combineIO :: IO a -> IO b -> (a -> b -> c) -> IO c
+combineIO io1 io2 f = do
+    a <- io1
+    b <- io2
+    return (f a b)
+```
+
+</details>
+
+### 問題 3: リトライ
+
+以下の関数を実装してください。指定回数リトライし、全部失敗したらデフォルト値を返します。
+
+```haskell
+retryWithDefault :: Int -> a -> IO a -> IO a
+retryWithDefault maxRetries defaultVal action = ???
+```
+
+<details>
+<summary>解答</summary>
+
+```haskell
+import Control.Exception (try, SomeException)
+
+retryWithDefault :: Int -> a -> IO a -> IO a
+retryWithDefault 0 defaultVal _ = return defaultVal
+retryWithDefault n defaultVal action = do
+    result <- try action :: IO (Either SomeException a)
+    case result of
+        Right a -> return a
+        Left _  -> retryWithDefault (n - 1) defaultVal action
+```
+
+</details>
+
+### 問題 4: ストリーム操作
+
+以下のストリームを作成してください。
+
+```haskell
+-- 1. 1から10までの偶数のリスト
+evens :: [Int]
+evens = ???
+
+-- 2. 無限に交互に True/False を返すリスト
+alternating :: [Bool]
+alternating = ???
+
+-- 3. 最初の5つの要素の合計を計算
+sumFirst5 :: [Int] -> Int
+sumFirst5 xs = ???
+```
+
+<details>
+<summary>解答</summary>
+
+```haskell
+-- 1. 1から10までの偶数
+evens :: [Int]
+evens = [2, 4, 6, 8, 10]
+-- または
+evens = filter even [1..10]
+
+-- 2. 無限に交互に True/False
+alternating :: [Bool]
+alternating = cycle [True, False]
+
+-- 3. 最初の5つの要素の合計
+sumFirst5 :: [Int] -> Int
+sumFirst5 xs = sum (take 5 xs)
+```
+
+</details>
+
+### 問題 5: トレンド検出
+
+以下の関数を実装してください。直近の値が減少傾向かどうかを判定します。
+
+```haskell
+declining :: Ord a => [a] -> Bool
+declining xs = ???
+
+-- 期待される動作
+-- declining [0.83, 0.82, 0.81]  -- True (減少トレンド)
+-- declining [0.81, 0.82, 0.83]  -- False
+-- declining [0.81]              -- False (1要素では判定不可)
+```
+
+<details>
+<summary>解答</summary>
+
+```haskell
+declining :: Ord a => [a] -> Bool
+declining xs =
+    length xs > 1 &&
+    all (uncurry (>)) (zip xs (tail xs))
+```
+
+</details>