@k2works/claude-code-booster 6.2.0 → 6.3.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/06-tdd-functional.md

@@ -1,292 +0,0 @@
----
-type: Article
-title: "第6章: テスト駆動開発と関数型プログラミング"
-description: "テスト駆動開発（TDD）は、テストを先に書いてから実装を行う開発手法です。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第6章: テスト駆動開発と関数型プログラミング
-
-## はじめに
-
-テスト駆動開発（TDD）は、テストを先に書いてから実装を行う開発手法です。関数型プログラミングと TDD は相性が良く、純粋関数はテストが容易で、不変データ構造は予測可能な動作を保証します。
-
-本章では、Red-Green-Refactor サイクルを Haskell で実践する方法を学びます。
-
-## 1. TDD の基本サイクル
-
-```plantuml
-@startuml
-title Red-Green-Refactor サイクル
-
-state "Red" as red : 失敗するテストを書く
-state "Green" as green : テストを通す最小限のコード
-state "Refactor" as refactor : コードを改善
-
-red --> green : 実装
-green --> refactor : クリーンアップ
-refactor --> red : 次のテスト
-
-@enduml
-```
-
-1. **Red（赤）**: 失敗するテストを書く
-2. **Green（緑）**: テストを通す最小限のコードを書く
-3. **Refactor（リファクタリング）**: コードを改善する
-
-## 2. FizzBuzz - TDD の典型例
-
-### Step 1: Red（最初のテスト）
-
-```haskell
--- test/TddFunctionalSpec.hs
-spec :: Spec
-spec = do
-    describe "FizzBuzz" $ do
-        it "1 returns \"1\"" $
-            fizzBuzz 1 `shouldBe` "1"
-```
-
-### Step 2: Green（最小限の実装）
-
-```haskell
--- src/TddFunctional.hs
-fizzBuzz :: Int -> String
-fizzBuzz _ = "1"
-```
-
-### Step 3: 次のテストを追加
-
-```haskell
-it "2 returns \"2\"" $
-    fizzBuzz 2 `shouldBe` "2"
-```
-
-### 段階的に実装を発展
-
-```haskell
--- 小さなヘルパー関数に分割
-fizz :: Int -> Bool
-fizz n = n `mod` 3 == 0
-
-buzz :: Int -> Bool
-buzz n = n `mod` 5 == 0
-
-fizzBuzz :: Int -> String
-fizzBuzz n
-    | fizz n && buzz n = "FizzBuzz"
-    | fizz n = "Fizz"
-    | buzz n = "Buzz"
-    | otherwise = show n
-```
-
-### 最終テストスイート
-
-```haskell
-describe "FizzBuzz (Basic TDD)" $ do
-    it "1 returns \"1\"" $
-        fizzBuzz 1 `shouldBe` "1"
-    it "2 returns \"2\"" $
-        fizzBuzz 2 `shouldBe` "2"
-    it "3 returns \"Fizz\"" $
-        fizzBuzz 3 `shouldBe` "Fizz"
-    it "5 returns \"Buzz\"" $
-        fizzBuzz 5 `shouldBe` "Buzz"
-    it "15 returns \"FizzBuzz\"" $
-        fizzBuzz 15 `shouldBe` "FizzBuzz"
-```
-
-## 3. ローマ数字変換
-
-### TDD で段階的に実装
-
-```haskell
--- Step 1: 最初のテスト
-it "converts 1 to I" $
-    toRoman 1 `shouldBe` "I"
-
--- Step 2: 最小限の実装
-toRoman :: Int -> String
-toRoman 1 = "I"
-toRoman _ = ""
-
--- Step 3: テストを追加しながら発展
-it "converts 4 to IV" $
-    toRoman 4 `shouldBe` "IV"
-it "converts 5 to V" $
-    toRoman 5 `shouldBe` "V"
-```
-
-### 完成した実装
-
-```haskell
-toRoman :: Int -> String
-toRoman n
-    | n <= 0 = ""
-    | n >= 1000 = "M" ++ toRoman (n - 1000)
-    | n >= 900 = "CM" ++ toRoman (n - 900)
-    | n >= 500 = "D" ++ toRoman (n - 500)
-    | n >= 400 = "CD" ++ toRoman (n - 400)
-    | n >= 100 = "C" ++ toRoman (n - 100)
-    | n >= 90 = "XC" ++ toRoman (n - 90)
-    | n >= 50 = "L" ++ toRoman (n - 50)
-    | n >= 40 = "XL" ++ toRoman (n - 40)
-    | n >= 10 = "X" ++ toRoman (n - 10)
-    | n >= 9 = "IX" ++ toRoman (n - 9)
-    | n >= 5 = "V" ++ toRoman (n - 5)
-    | n >= 4 = "IV" ++ toRoman (n - 4)
-    | otherwise = "I" ++ toRoman (n - 1)
-
-fromRoman :: String -> Int
-fromRoman = go 0
-  where
-    go acc [] = acc
-    go acc [x] = acc + romanCharValue x
-    go acc (x:y:rest)
-        | romanCharValue x < romanCharValue y = go (acc - romanCharValue x) (y:rest)
-        | otherwise = go (acc + romanCharValue x) (y:rest)
-    
-    romanCharValue 'I' = 1
-    romanCharValue 'V' = 5
-    romanCharValue 'X' = 10
-    romanCharValue 'L' = 50
-    romanCharValue 'C' = 100
-    romanCharValue 'D' = 500
-    romanCharValue 'M' = 1000
-    romanCharValue _ = 0
-```
-
-## 4. ボウリングスコア
-
-### ゲームの状態
-
-```haskell
-type Game = ([Int], Int)  -- (rolls, current frame)
-
-newGame :: Game
-newGame = ([], 1)
-
-roll :: Int -> Game -> Game
-roll pins (rolls, frame) = (rolls ++ [pins], frame)
-```
-
-### スコア計算
-
-```haskell
-score :: Game -> Int
-score (rolls, _) = scoreFrames rolls 1 0
-
-scoreFrames :: [Int] -> Int -> Int -> Int
-scoreFrames _ 11 acc = acc  -- 10フレーム超えたら終了
-scoreFrames [] _ acc = acc
-scoreFrames rolls@(r1:rest) frame acc
-    | frame == 10 = acc + sum rolls  -- 10フレーム目
-    | r1 == 10 = scoreFrames rest (frame + 1) (acc + 10 + bonus2 rest)  -- Strike
-    | otherwise = case rest of
-        [] -> acc + r1
-        (r2:rest2)
-            | r1 + r2 == 10 -> scoreFrames rest2 (frame + 1) (acc + 10 + bonus1 rest2)  -- Spare
-            | otherwise -> scoreFrames rest2 (frame + 1) (acc + r1 + r2)
-  where
-    bonus1 (x:_) = x
-    bonus1 [] = 0
-    bonus2 (x:y:_) = x + y
-    bonus2 (x:_) = x
-    bonus2 [] = 0
-```
-
-### テスト
-
-```haskell
-describe "Bowling Game" $ do
-    it "starts with score 0" $
-        score newGame `shouldBe` 0
-    
-    it "scores 0 for all zeros" $ do
-        let game = foldr roll newGame (replicate 20 0)
-        score game `shouldBe` 0
-    
-    it "scores 20 for all ones" $ do
-        let game = foldr roll newGame (replicate 20 1)
-        score game `shouldBe` 20
-    
-    it "spare adds next roll bonus" $ do
-        let rolls = [5, 5, 3] ++ replicate 17 0
-        let game = foldr roll newGame (reverse rolls)
-        score game `shouldBe` 16
-```
-
-## 5. String Calculator Kata
-
-```haskell
-add :: String -> Int
-add "" = 0
-add s = sum $ parseNumbers s
-
-parseNumbers :: String -> [Int]
-parseNumbers s = map read $ splitOn ',' $ map replaceNewline s
-  where
-    replaceNewline '\n' = ','
-    replaceNewline c = c
-    
-    splitOn _ [] = []
-    splitOn delim str = 
-        let (before, after) = break (== delim) str
-        in before : case after of
-            [] -> []
-            (_:rest) -> splitOn delim rest
-```
-
-## 6. 素因数分解
-
-```haskell
-primeFactors :: Int -> [Int]
-primeFactors n = factorize n 2
-  where
-    factorize 1 _ = []
-    factorize num factor
-        | factor * factor > num = [num]
-        | num `mod` factor == 0 = factor : factorize (num `div` factor) factor
-        | otherwise = factorize num (factor + 1)
-```
-
-### テスト
-
-```haskell
-describe "Prime Factors" $ do
-    it "returns empty for 1" $
-        primeFactors 1 `shouldBe` []
-    it "returns [2] for 2" $
-        primeFactors 2 `shouldBe` [2]
-    it "returns [2,2] for 4" $
-        primeFactors 4 `shouldBe` [2, 2]
-    it "returns [2,3] for 6" $
-        primeFactors 6 `shouldBe` [2, 3]
-    
-    -- プロパティベーステスト
-    it "product of factors equals original" $ property $
-        \(Positive n) ->
-            let n' = max 2 (n `mod` 1000)
-            in product (primeFactors n') == n'
-```
-
-## 7. まとめ
-
-### TDD と FP の相性
-
-| 特徴 | メリット |
-|-----|---------|
-| 純粋関数 | 入出力が明確でテストしやすい |
-| 不変データ | 状態管理の複雑さがない |
-| 型システム | 多くのバグをコンパイル時に検出 |
-| パターンマッチ | 網羅的なケース処理 |
-
-### TDD のベストプラクティス
-
-1. **小さなステップで進める**: 一度に大きな変更をしない
-2. **最初に失敗するテストを書く**: テストが本当に機能していることを確認
-3. **最小限のコードで通す**: 過度な一般化を避ける
-4. **リファクタリングはグリーンの後**: テストが通った状態でのみ改善
-5. **プロパティベーステストを併用**: エッジケースの発見

package/lib/assets/docs/article/functional-desgin-ppp/haskell/07-composite-pattern.md

@@ -1,404 +0,0 @@
----
-type: Article
-title: "第7章: Composite パターン"
-description: "Composite パターンは、オブジェクトをツリー構造で構成し、個々のオブジェクトとオブジェクトの集合を同じように扱うことができるようにするパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第7章: Composite パターン
-
-## はじめに
-
-Composite パターンは、オブジェクトをツリー構造で構成し、個々のオブジェクトとオブジェクトの集合を同じように扱うことができるようにするパターンです。このパターンを使用すると、クライアントは個々のオブジェクトとその組み合わせを区別せずに操作できます。
-
-本章では、図形（Shape）、スイッチ（Switchable）、ファイルシステム、メニュー、数式、組織構造など、様々な例を通じて Composite パターンの実装を学びます。
-
-## 1. パターンの構造
-
-Composite パターンは以下の要素で構成されます：
-
-- **Component**: 全てのオブジェクトの共通インターフェース
-- **Leaf**: 子要素を持たない末端オブジェクト
-- **Composite**: 子要素を持つコンテナオブジェクト
-
-```plantuml
-@startuml
-skinparam classAttributeIconSize 0
-
-abstract class Component {
-  +operation(): Result
-}
-
-class Leaf {
-  +operation()
-}
-
-class Composite {
-  -children: [Component]
-  +add(c: Component)
-  +operation()
-}
-
-Component <|-- Leaf
-Component <|-- Composite
-Composite o-- Component : children
-@enduml
-```
-
-## 2. Shape - 図形の Composite パターン
-
-### 代数的データ型による実装
-
-Haskell では代数的データ型（ADT）を使って Component を表現します：
-
-```haskell
--- | 2D Point
-data Point = Point
-  { pointX :: Double
-  , pointY :: Double
-  } deriving (Show, Eq)
-
--- | Shape - Composite pattern for geometric shapes
-data Shape
-  = Circle Point Double           -- ^ Circle with center and radius
-  | Square Point Double           -- ^ Square with top-left corner and side length
-  | Rectangle Point Double Double -- ^ Rectangle with top-left, width, and height
-  | CompositeShape [Shape]        -- ^ Composite containing multiple shapes
-  deriving (Show, Eq)
-```
-
-### 再帰的な操作
-
-```haskell
--- | Translate a shape by (dx, dy)
-translateShape :: Double -> Double -> Shape -> Shape
-translateShape dx dy shape = case shape of
-  Circle (Point x y) r -> Circle (Point (x + dx) (y + dy)) r
-  Square (Point x y) s -> Square (Point (x + dx) (y + dy)) s
-  Rectangle (Point x y) w h -> Rectangle (Point (x + dx) (y + dy)) w h
-  CompositeShape shapes -> CompositeShape (map (translateShape dx dy) shapes)
-
--- | Scale a shape by a factor
-scaleShape :: Double -> Shape -> Shape
-scaleShape factor shape = case shape of
-  Circle c r -> Circle c (r * factor)
-  Square tl s -> Square tl (s * factor)
-  Rectangle tl w h -> Rectangle tl (w * factor) (h * factor)
-  CompositeShape shapes -> CompositeShape (map (scaleShape factor) shapes)
-
--- | Calculate the area of a shape
-shapeArea :: Shape -> Double
-shapeArea shape = case shape of
-  Circle _ r -> pi * r * r
-  Square _ s -> s * s
-  Rectangle _ w h -> w * h
-  CompositeShape shapes -> sum (map shapeArea shapes)
-```
-
-### 使用例
-
-```haskell
--- 個々の図形を作成
-let circle = Circle (Point 10 10) 5
-let square = Square (Point 0 0) 10
-
--- 複合図形を作成
-let group = addShape square (addShape circle emptyComposite)
--- CompositeShape [Circle (Point 10 10) 5, Square (Point 0 0) 10]
-
--- 複合図形を移動（全ての子要素が移動する）
-let moved = translateShape 5 5 group
--- CompositeShape [Circle (Point 15 15) 5, Square (Point 5 5) 10]
-
--- 複合図形を拡大（全ての子要素が拡大する）
-let scaled = scaleShape 2 group
--- CompositeShape [Circle (Point 10 10) 10, Square (Point 0 0) 20]
-
--- 面積は全ての子要素の合計
-let totalArea = shapeArea group  -- pi * 25 + 100
-```
-
-## 3. Switchable - スイッチの Composite パターン
-
-```haskell
--- | Switchable - Composite pattern for switchable devices
-data Switchable
-  = Light String Bool             -- ^ Light with name and on/off state
-  | DimmableLight String Int      -- ^ Dimmable light with name and intensity (0-100)
-  | Fan String Bool Int           -- ^ Fan with name, on/off state, and speed
-  | CompositeSwitchable String [Switchable]  -- ^ Composite with name and list
-  deriving (Show, Eq)
-
--- | Turn on a switchable
-turnOn :: Switchable -> Switchable
-turnOn switchable = case switchable of
-  Light name _ -> Light name True
-  DimmableLight name _ -> DimmableLight name 100
-  Fan name _ speed -> Fan name True (max speed 1)
-  CompositeSwitchable name items -> CompositeSwitchable name (map turnOn items)
-
--- | Check if a switchable is on
-isOn :: Switchable -> Bool
-isOn switchable = case switchable of
-  Light _ on -> on
-  DimmableLight _ intensity -> intensity > 0
-  Fan _ on _ -> on
-  CompositeSwitchable _ items -> any isOn items
-```
-
-### 使用例
-
-```haskell
--- 部屋のスイッチグループを作成
-let bedroom = emptySwitchableComposite "Bedroom"
-            |> addSwitchable (Light "Ceiling" False)
-            |> addSwitchable (DimmableLight "Bedside" 0)
-
-let livingRoom = emptySwitchableComposite "LivingRoom"
-               |> addSwitchable (Light "Main" False)
-               |> addSwitchable (Fan "CeilingFan" False 0)
-
--- 家全体のグループ
-let house = emptySwitchableComposite "House"
-          |> addSwitchable bedroom
-          |> addSwitchable livingRoom
-
--- 家中の全てのスイッチをオン
-let allOn = turnOn house
-```
-
-## 4. FileSystem - ファイルシステムの Composite パターン
-
-```haskell
--- | FileSystemEntry - Composite pattern for file system
-data FileSystemEntry
-  = File String Int String        -- ^ File with name, size, and extension
-  | Directory String [FileSystemEntry]  -- ^ Directory with name and children
-  deriving (Show, Eq)
-
--- | Get the total size of a file system entry
-fileSize :: FileSystemEntry -> Int
-fileSize entry = case entry of
-  File _ size _ -> size
-  Directory _ children -> sum (map fileSize children)
-
--- | Find files by extension
-findByExtension :: String -> FileSystemEntry -> [FileSystemEntry]
-findByExtension ext entry = case entry of
-  File _ _ fileExt | fileExt == ext -> [entry]
-  File {} -> []
-  Directory _ children -> concatMap (findByExtension ext) children
-```
-
-### 使用例
-
-```haskell
--- ファイルシステム構造を構築
-let readme = File "readme.txt" 1024 ".txt"
-let config = File "config.json" 512 ".json"
-let src = Directory "src" 
-      [ File "main.fs" 2048 ".fs"
-      , File "util.fs" 1024 ".fs"
-      ]
-let root = Directory "project" [readme, config, src]
-
--- 総サイズを取得
-let totalSize = fileSize root  -- 4608
-
--- .fs ファイルを検索
-let fsFiles = findByExtension ".fs" root  -- 2 files
-```
-
-## 5. MenuItem - メニューの Composite パターン
-
-```haskell
--- | MenuItem - Composite pattern for menu items
-data MenuItem
-  = Item String Double String     -- ^ Item with name, price, and category
-  | SetMenu String [MenuItem] Double  -- ^ Set menu with name, items, and discount rate
-  deriving (Show, Eq)
-
--- | Calculate the price of a menu item
-menuPrice :: MenuItem -> Double
-menuPrice item = case item of
-  Item _ price _ -> price
-  SetMenu _ items discountRate -> 
-    let totalPrice = sum (map menuPrice items)
-    in totalPrice * (1 - discountRate)
-```
-
-### 使用例
-
-```haskell
--- 単品メニュー
-let burger = Item "Hamburger" 500 "Main"
-let fries = Item "Fries" 200 "Side"
-let drink = Item "Cola" 150 "Drink"
-
--- セットメニュー（10%割引）
-let lunchSet = SetMenu "Lunch Set" [burger, fries, drink] 0.1
-
--- セット価格 = (500 + 200 + 150) * 0.9 = 765
-let setPrice = menuPrice lunchSet
-```
-
-## 6. Expression - 数式の Composite パターン
-
-```haskell
--- | Expression - Composite pattern for mathematical expressions
-data Expr
-  = Number Double                 -- ^ Numeric literal
-  | Variable String (Maybe Double)  -- ^ Variable with optional bound value
-  | Add Expr Expr                 -- ^ Addition
-  | Subtract Expr Expr            -- ^ Subtraction
-  | Multiply Expr Expr            -- ^ Multiplication
-  | Divide Expr Expr              -- ^ Division
-  | Negate Expr                   -- ^ Negation
-  deriving (Show, Eq)
-
--- | Evaluate an expression
-evaluate :: Expr -> Maybe Double
-evaluate expr = case expr of
-  Number n -> Just n
-  Variable _ (Just v) -> Just v
-  Variable _ Nothing -> Nothing  -- Unbound variable
-  Add l r -> (+) <$> evaluate l <*> evaluate r
-  Subtract l r -> (-) <$> evaluate l <*> evaluate r
-  Multiply l r -> (*) <$> evaluate l <*> evaluate r
-  Divide l r -> do
-    lv <- evaluate l
-    rv <- evaluate r
-    if rv == 0 then Nothing else Just (lv / rv)
-  Negate e -> negate <$> evaluate e
-
--- | Simplify an expression
-simplify :: Expr -> Expr
-simplify expr = case expr of
-  Add l r -> case (simplify l, simplify r) of
-    (Number 0, r') -> r'
-    (l', Number 0) -> l'
-    (Number a, Number b) -> Number (a + b)
-    (l', r') -> Add l' r'
-  -- ... other cases
-```
-
-### 使用例
-
-```haskell
--- (2 + 3) * 4 = 20
-let expr = Multiply (Add (Number 2) (Number 3)) (Number 4)
-let result = evaluate expr  -- Just 20
-
--- 変数を含む式
-let exprWithVars = Add (Variable "x" Nothing) (Variable "y" Nothing)
-let bound = bindVars [("x", 10), ("y", 20)] exprWithVars
-let value = evaluate bound  -- Just 30
-
--- 式の簡略化
-let simplified = simplify (Add (Variable "x" Nothing) (Number 0))
--- => Variable "x" Nothing
-```
-
-## 7. Organization - 組織構造の Composite パターン
-
-```haskell
--- | OrganizationMember - Composite pattern for organizational structure
-data OrganizationMember
-  = Employee String Double String  -- ^ Employee with name, salary, and role
-  | Department String (Maybe String) [OrganizationMember]  
-      -- ^ Department with name, manager, and members
-  deriving (Show, Eq)
-
--- | Calculate the total salary
-totalSalary :: OrganizationMember -> Double
-totalSalary member = case member of
-  Employee _ salary _ -> salary
-  Department _ _ members -> sum (map totalSalary members)
-
--- | Find employees by role
-findByRole :: String -> OrganizationMember -> [OrganizationMember]
-findByRole role member = case member of
-  Employee _ _ r | r == role -> [member]
-  Employee {} -> []
-  Department _ _ members -> concatMap (findByRole role) members
-```
-
-## パターンの利点
-
-1. **統一的な操作**: 個々のオブジェクトとグループを同じインターフェースで操作可能
-2. **階層構造**: ネストした構造を自然に表現可能
-3. **拡張性**: 新しい Leaf や Composite を追加しやすい
-4. **再帰的な構造**: Composite は他の Composite を含むことも可能
-
-## Haskell での特徴
-
-### 代数的データ型による型安全性
-
-```haskell
--- 全てのケースを網羅するパターンマッチ
-shapeArea :: Shape -> Double
-shapeArea shape = case shape of
-  Circle _ r -> pi * r * r
-  Square _ s -> s * s
-  Rectangle _ w h -> w * h
-  CompositeShape shapes -> sum (map shapeArea shapes)
-  -- 新しいケースを追加すると、コンパイラが警告を出す
-```
-
-### 不変性による安全な操作
-
-```haskell
--- 元のオブジェクトは変更されない
-let original = addShape (Circle (Point 0 0) 5) emptyComposite
-let moved = translateShape 10 10 original
--- original は変更されていない
-```
-
-### 再帰関数と高階関数
-
-```haskell
--- 再帰的な処理も簡潔に
-let result = emptyComposite
-           & addShape circle
-           & addShape square
-           & translateShape 5 5
-           & scaleShape 2
-           & shapeArea
-```
-
-## Clojure/F# との比較
-
-| 概念 | Clojure | F# | Haskell |
-|------|---------|-----|---------|
-| インターフェース | マルチメソッド | 判別共用体 | ADT |
-| Leaf | defmethod | Union case | Constructor |
-| Composite | defmethod + mapv | Union case with list | Constructor with list |
-| 操作の委譲 | mapv | List.map | map |
-| 不変性 | デフォルト | デフォルト | 強制 |
-| 網羅性チェック | なし | 完全チェック | 完全チェック |
-
-## まとめ
-
-本章では、Composite パターンについて学びました：
-
-1. **Shape の例**: 図形の移動と拡大を統一的に操作
-2. **Switchable の例**: 複数のスイッチをグループ化して操作
-3. **FileSystem の例**: ファイルとディレクトリの階層構造
-4. **Menu の例**: 単品とセットメニューの価格計算
-5. **Expression の例**: 数式の評価と簡略化
-6. **Organization の例**: 組織構造の給与計算
-
-Composite パターンは、ツリー構造のデータを扱う際に非常に有効なパターンです。Haskell の代数的データ型とパターンマッチを使うことで、型安全で不変なツリー構造を簡潔に実装できます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/haskell/part3/src/CompositePattern.hs`
-- テストコード: `apps/haskell/part3/test/CompositePatternSpec.hs`
-
-## 次章予告
-
-次章では、**Decorator パターン**について学びます。既存の機能に新しい機能を動的に追加する方法を探ります。