@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/10-strategy-pattern.md

@@ -0,0 +1,287 @@
+# 第10章: Strategy パターン
+
+## はじめに
+
+Strategy パターンは、アルゴリズムを個別に定義し、それらを交換可能にするパターンです。これにより、アルゴリズムをクライアントから独立して変更できます。
+
+本章では、価格計算戦略、配送戦略、ショッピングカート、戦略の合成、ソートアルゴリズムなどを通じて Strategy パターンの実装を学びます。
+
+## 1. パターンの構造
+
+Strategy パターンは以下の要素で構成されます：
+
+- **Strategy**: アルゴリズムの共通インターフェース
+- **ConcreteStrategy**: 具体的なアルゴリズムの実装
+- **Context**: Strategy を使用するクラス
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+interface Strategy {
+  +execute(data): Result
+}
+
+class ConcreteStrategyA {
+  +execute(data): Result
+}
+
+class ConcreteStrategyB {
+  +execute(data): Result
+}
+
+class Context {
+  -strategy: Strategy
+  +setStrategy(s: Strategy)
+  +executeStrategy(data): Result
+}
+
+Strategy <|.. ConcreteStrategyA
+Strategy <|.. ConcreteStrategyB
+Context o-- Strategy
+@enduml
+```
+
+## 2. 価格計算戦略
+
+### newtype による戦略の定義
+
+Haskell では関数を `newtype` でラップして戦略を表現します：
+
+```haskell
+-- | Pricing strategy is a function from amount to final price
+newtype PricingStrategy = PricingStrategy
+  { runPricing :: Double -> Double
+  }
+
+-- | Apply pricing strategy
+calculatePrice :: PricingStrategy -> Double -> Double
+calculatePrice = runPricing
+```
+
+### 具体的な戦略の実装
+
+```haskell
+-- | Regular pricing (no change)
+regularPricing :: PricingStrategy
+regularPricing = PricingStrategy id
+
+-- | Percentage discount
+discountPricing :: Double -> PricingStrategy
+discountPricing percentage = PricingStrategy $ \amount ->
+  amount * (1 - percentage)
+
+-- | Fixed discount
+fixedDiscountPricing :: Double -> PricingStrategy
+fixedDiscountPricing discount = PricingStrategy $ \amount ->
+  max 0 (amount - discount)
+
+-- | Bulk discount: apply percentage if amount exceeds threshold
+bulkDiscountPricing :: Double -> Double -> PricingStrategy
+bulkDiscountPricing threshold percentage = PricingStrategy $ \amount ->
+  if amount >= threshold
+    then amount * (1 - percentage)
+    else amount
+```
+
+### 使用例
+
+```haskell
+-- 10% ディスカウント
+let strategy = discountPricing 0.10
+calculatePrice strategy 1000  -- 900.0
+
+-- 5000円以上で20%ディスカウント
+let bulkStrategy = bulkDiscountPricing 5000 0.20
+calculatePrice bulkStrategy 6000  -- 4800.0
+calculatePrice bulkStrategy 4000  -- 4000.0
+```
+
+## 3. 配送戦略
+
+### 重量と距離に基づく配送料金
+
+```haskell
+-- | Shipping strategy takes weight and distance, returns shipping cost
+newtype ShippingStrategy = ShippingStrategy
+  { runShipping :: Double -> Double -> Double
+  }
+
+-- | Calculate shipping cost
+calculateShipping :: ShippingStrategy -> Double -> Double -> Double
+calculateShipping = runShipping
+
+-- | Standard shipping: $0.05 per kg per km
+standardShipping :: ShippingStrategy
+standardShipping = ShippingStrategy $ \weight distance ->
+  weight * distance * 0.05
+
+-- | Express shipping: 2x standard
+expressShipping :: ShippingStrategy
+expressShipping = ShippingStrategy $ \weight distance ->
+  weight * distance * 0.10
+
+-- | Free shipping
+freeShipping :: ShippingStrategy
+freeShipping = ShippingStrategy $ \_ _ -> 0
+```
+
+## 4. ショッピングカート
+
+### 戦略を持つコンテキスト
+
+```haskell
+-- | Cart item
+data CartItem = CartItem
+  { itemName :: String
+  , itemPrice :: Double
+  , itemQuantity :: Int
+  } deriving (Show, Eq)
+
+-- | Shopping cart with pricing strategy
+data ShoppingCart = ShoppingCart
+  { cartItems :: [CartItem]
+  , cartPricingStrategy :: PricingStrategy
+  }
+
+-- | Create an empty cart with regular pricing
+makeCart :: ShoppingCart
+makeCart = ShoppingCart [] regularPricing
+
+-- | Add item to cart
+addItem :: CartItem -> ShoppingCart -> ShoppingCart
+addItem item cart = cart { cartItems = item : cartItems cart }
+
+-- | Calculate subtotal
+cartSubtotal :: ShoppingCart -> Double
+cartSubtotal cart = sum [itemPrice i * fromIntegral (itemQuantity i) 
+                        | i <- cartItems cart]
+
+-- | Calculate total with pricing strategy
+cartTotal :: ShoppingCart -> Double
+cartTotal cart = calculatePrice (cartPricingStrategy cart) (cartSubtotal cart)
+
+-- | Change pricing strategy
+changeStrategy :: PricingStrategy -> ShoppingCart -> ShoppingCart
+changeStrategy strategy cart = cart { cartPricingStrategy = strategy }
+```
+
+## 5. 戦略の合成
+
+### 戦略をモノイドとして合成
+
+```haskell
+-- | Compose multiple pricing strategies (apply left to right)
+composeStrategies :: [PricingStrategy] -> PricingStrategy
+composeStrategies strategies = PricingStrategy $ \amount ->
+  foldl (flip runPricing) amount strategies
+
+-- | Conditional strategy
+conditionalStrategy :: (Double -> Bool) -> PricingStrategy -> PricingStrategy -> PricingStrategy
+conditionalStrategy predicate thenStrategy elseStrategy = PricingStrategy $ \amount ->
+  if predicate amount
+    then runPricing thenStrategy amount
+    else runPricing elseStrategy amount
+
+-- | Tax strategy
+taxStrategy :: Double -> PricingStrategy
+taxStrategy rate = PricingStrategy $ \amount -> amount * (1 + rate)
+```
+
+### 使用例
+
+```haskell
+-- 10%ディスカウント後に8%の税金
+let discount = discountPricing 0.10
+    tax = taxStrategy 0.08
+    composed = composeStrategies [discount, tax]
+calculatePrice composed 1000  -- 972.0
+```
+
+## 6. ソート戦略
+
+### 複数のソートアルゴリズム
+
+```haskell
+-- | Sorting strategy
+newtype SortStrategy a = SortStrategy
+  { runSort :: [a] -> [a]
+  }
+
+-- | Sort with a strategy
+sortWith :: Ord a => SortStrategy a -> [a] -> [a]
+sortWith strategy = runSort strategy
+
+-- | Bubble sort
+bubbleSort :: Ord a => SortStrategy a
+bubbleSort = SortStrategy bubble
+  where
+    bubble [] = []
+    bubble xs = let (sorted, rest) = bubblePass xs
+                in if null rest then sorted else bubble sorted
+    bubblePass [] = ([], [])
+    bubblePass [x] = ([x], [])
+    bubblePass (x:y:xs)
+      | x > y = let (sorted, rest) = bubblePass (x:xs) in (y:sorted, rest)
+      | otherwise = let (sorted, rest) = bubblePass (y:xs) in (x:sorted, rest)
+
+-- | Quick sort
+quickSort :: Ord a => SortStrategy a
+quickSort = SortStrategy qsort
+  where
+    qsort [] = []
+    qsort (x:xs) = qsort [y | y <- xs, y < x] 
+                   ++ [x] 
+                   ++ qsort [y | y <- xs, y >= x]
+
+-- | Merge sort
+mergeSort :: Ord a => SortStrategy a
+mergeSort = SortStrategy msort
+  where
+    msort [] = []
+    msort [x] = [x]
+    msort xs = merge (msort left) (msort right)
+      where
+        (left, right) = splitAt (length xs `div` 2) xs
+    merge xs [] = xs
+    merge [] ys = ys
+    merge (x:xs) (y:ys)
+      | x <= y    = x : merge xs (y:ys)
+      | otherwise = y : merge (x:xs) ys
+```
+
+## 7. テスト
+
+```haskell
+describe "Pricing Strategies" $ do
+  it "applies regular pricing" $ do
+    calculatePrice regularPricing 100 `shouldBe` 100
+  
+  it "applies percentage discount" $ do
+    calculatePrice (discountPricing 0.20) 100 `shouldBe` 80
+  
+  it "applies bulk discount when threshold met" $ do
+    calculatePrice (bulkDiscountPricing 5000 0.20) 6000 `shouldBe` 4800
+
+describe "Shopping Cart" $ do
+  it "calculates total with strategy" $ do
+    let cart = addItem (CartItem "Book" 1000 2) 
+             $ changeStrategy (discountPricing 0.10) makeCart
+    cartTotal cart `shouldBe` 1800
+
+describe "Sorting Strategies" $ do
+  it "all strategies produce same result" $ property $ \xs ->
+    let sorted = sort (xs :: [Int])
+    in sortWith quickSort xs == sorted 
+       && sortWith mergeSort xs == sorted
+```
+
+## まとめ
+
+Strategy パターンの Haskell における実装のポイント：
+
+1. **関数ファースト**: 戦略を関数として表現し、`newtype` でラップ
+2. **型安全性**: 異なる戦略の型を分離（`PricingStrategy` vs `ShippingStrategy`）
+3. **合成可能性**: 戦略を合成して複雑な振る舞いを構築
+4. **テスト容易性**: 純粋関数として戦略をテスト可能
+5. **QuickCheck**: プロパティベーステストで戦略の正当性を検証

package/lib/assets/docs/article/functional-desgin-ppp/haskell/11-command-pattern.md

@@ -0,0 +1,303 @@
+# 第11章: Command パターン
+
+## はじめに
+
+Command パターンは、リクエストをオブジェクトとしてカプセル化し、異なるリクエストでクライアントをパラメータ化したり、リクエストをキューに入れたり、操作の履歴を記録したりすることができるパターンです。
+
+本章では、テキスト編集コマンド、キャンバス操作コマンド、Undo/Redo 機能、バッチ処理、マクロコマンドなどを通じて Command パターンの実装を学びます。
+
+## 1. パターンの構造
+
+Command パターンは以下の要素で構成されます：
+
+- **Command**: コマンドの共通インターフェース
+- **ConcreteCommand**: 具体的なコマンドの実装
+- **Invoker**: コマンドを実行するクラス
+- **Receiver**: コマンドが操作する対象
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+interface Command {
+  +execute(): Result
+  +undo(): Result
+}
+
+class ConcreteCommand {
+  -receiver: Receiver
+  +execute(): Result
+  +undo(): Result
+}
+
+class Invoker {
+  -history: [Command]
+  +executeCommand(c: Command)
+  +undo()
+  +redo()
+}
+
+class Receiver {
+  +action()
+}
+
+Command <|.. ConcreteCommand
+Invoker o-- Command
+ConcreteCommand --> Receiver
+@enduml
+```
+
+## 2. テキスト編集コマンド
+
+### ADT によるコマンドの定義
+
+```haskell
+-- | Text editing commands
+data TextCommand
+  = InsertCommand Int String    -- ^ Insert text at position
+  | DeleteCommand Int Int       -- ^ Delete from position with length
+  | ReplaceCommand Int String String  -- ^ Replace old with new at position
+  deriving (Show, Eq)
+
+-- | Execute a text command on a string
+executeTextCommand :: TextCommand -> String -> String
+executeTextCommand cmd text = case cmd of
+  InsertCommand pos str ->
+    let (before, after) = splitAt pos text
+    in before ++ str ++ after
+  
+  DeleteCommand pos len ->
+    let (before, rest) = splitAt pos text
+        (_, after) = splitAt len rest
+    in before ++ after
+  
+  ReplaceCommand pos old new ->
+    let (before, rest) = splitAt pos text
+        (_, after) = splitAt (length old) rest
+    in before ++ new ++ after
+```
+
+### Undo の実装
+
+```haskell
+-- | Undo a text command
+undoTextCommand :: TextCommand -> String -> String
+undoTextCommand cmd text = case cmd of
+  InsertCommand pos str ->
+    let (before, rest) = splitAt pos text
+        (_, after) = splitAt (length str) rest
+    in before ++ after
+  
+  DeleteCommand pos len ->
+    -- Note: needs original deleted text for proper undo
+    text
+  
+  ReplaceCommand pos old new ->
+    let (before, rest) = splitAt pos text
+        (_, after) = splitAt (length new) rest
+    in before ++ old ++ after
+```
+
+## 3. キャンバスコマンド
+
+### 図形操作のコマンド
+
+```haskell
+-- | Canvas shape
+data CanvasShape = CanvasShape
+  { shapeId :: Int
+  , shapeType :: String
+  , shapeX :: Double
+  , shapeY :: Double
+  } deriving (Show, Eq)
+
+-- | Canvas state
+type Canvas = [CanvasShape]
+
+-- | Canvas commands
+data CanvasCommand
+  = AddShapeCommand CanvasShape
+  | MoveShapeCommand Int Double Double  -- ^ id, dx, dy
+  | DeleteShapeCommand Int
+  deriving (Show, Eq)
+
+-- | Execute canvas command
+executeCanvasCommand :: CanvasCommand -> Canvas -> Canvas
+executeCanvasCommand cmd canvas = case cmd of
+  AddShapeCommand shape -> shape : canvas
+  
+  MoveShapeCommand shapeId dx dy ->
+    map (\s -> if shapeId == CanvasShape.shapeId s
+               then s { shapeX = shapeX s + dx, shapeY = shapeY s + dy }
+               else s) canvas
+  
+  DeleteShapeCommand shapeId ->
+    filter (\s -> CanvasShape.shapeId s /= shapeId) canvas
+```
+
+## 4. 汎用的なコマンドエグゼキュータ
+
+### Undo/Redo スタックの実装
+
+```haskell
+-- | Command executor with undo/redo support
+data CommandExecutor cmd state = CommandExecutor
+  { executorState :: state
+  , executorUndoStack :: [(cmd, state)]  -- ^ (command, state before execution)
+  , executorRedoStack :: [(cmd, state)]
+  }
+
+-- | Create a new executor
+makeExecutor :: state -> CommandExecutor cmd state
+makeExecutor initialState = CommandExecutor
+  { executorState = initialState
+  , executorUndoStack = []
+  , executorRedoStack = []
+  }
+
+-- | Execute a command
+executeCommand :: (cmd -> state -> state) 
+               -> cmd 
+               -> CommandExecutor cmd state 
+               -> CommandExecutor cmd state
+executeCommand exec cmd executor = CommandExecutor
+  { executorState = exec cmd (executorState executor)
+  , executorUndoStack = (cmd, executorState executor) : executorUndoStack executor
+  , executorRedoStack = []  -- Clear redo stack on new command
+  }
+```
+
+### Undo と Redo
+
+```haskell
+-- | Undo the last command
+undoCommand :: (cmd -> state -> state)
+            -> CommandExecutor cmd state
+            -> CommandExecutor cmd state
+undoCommand undoFn executor = case executorUndoStack executor of
+  [] -> executor  -- Nothing to undo
+  ((cmd, prevState) : rest) -> CommandExecutor
+    { executorState = prevState
+    , executorUndoStack = rest
+    , executorRedoStack = (cmd, executorState executor) : executorRedoStack executor
+    }
+
+-- | Redo the last undone command
+redoCommand :: (cmd -> state -> state)
+            -> CommandExecutor cmd state
+            -> CommandExecutor cmd state
+redoCommand exec executor = case executorRedoStack executor of
+  [] -> executor  -- Nothing to redo
+  ((cmd, _) : rest) -> CommandExecutor
+    { executorState = exec cmd (executorState executor)
+    , executorUndoStack = (cmd, executorState executor) : executorUndoStack executor
+    , executorRedoStack = rest
+    }
+```
+
+## 5. バッチ処理
+
+```haskell
+-- | Execute multiple commands in sequence
+executeBatch :: (cmd -> state -> state)
+             -> [cmd]
+             -> CommandExecutor cmd state
+             -> CommandExecutor cmd state
+executeBatch exec commands executor =
+  foldl (flip (executeCommand exec)) executor commands
+
+-- | Undo all commands
+undoAll :: (cmd -> state -> state)
+        -> CommandExecutor cmd state
+        -> CommandExecutor cmd state
+undoAll undoFn executor =
+  iterate (undoCommand undoFn) executor !! length (executorUndoStack executor)
+```
+
+## 6. マクロコマンド
+
+```haskell
+-- | Macro command (composite of commands)
+newtype MacroCommand cmd = MacroCommand { macroCommands :: [cmd] }
+  deriving (Show, Eq)
+
+-- | Create a macro from commands
+makeMacro :: [cmd] -> MacroCommand cmd
+makeMacro = MacroCommand
+
+-- | Execute a macro command
+executeMacro :: (cmd -> state -> state)
+             -> MacroCommand cmd
+             -> state
+             -> state
+executeMacro exec (MacroCommand cmds) state =
+  foldl (flip exec) state cmds
+
+-- | Undo a macro command (in reverse order)
+undoMacro :: (cmd -> state -> state)
+          -> MacroCommand cmd
+          -> state
+          -> state
+undoMacro undoFn (MacroCommand cmds) state =
+  foldl (flip undoFn) state (reverse cmds)
+```
+
+## 7. 使用例
+
+```haskell
+-- テキスト編集の例
+let initial = "Hello World"
+    executor = makeExecutor initial
+    
+-- コマンドを実行
+let executor' = executeCommand executeTextCommand 
+                              (InsertCommand 5 ",") executor
+-- "Hello, World"
+
+-- Undo
+let executor'' = undoCommand undoTextCommand executor'
+-- "Hello World"
+
+-- バッチ実行
+let commands = [ InsertCommand 0 ">>> "
+               , InsertCommand 15 " <<<"
+               ]
+    result = executeBatch executeTextCommand commands executor
+-- ">>> Hello World <<<"
+```
+
+## 8. テスト
+
+```haskell
+describe "Text Commands" $ do
+  describe "InsertCommand" $ do
+    it "inserts text at position" $ do
+      executeTextCommand (InsertCommand 5 ", ") "HelloWorld" 
+        `shouldBe` "Hello, World"
+    
+    it "undoes insert" $ do
+      let cmd = InsertCommand 5 ", "
+          result = executeTextCommand cmd "HelloWorld"
+      undoTextCommand cmd result `shouldBe` "HelloWorld"
+
+describe "CommandExecutor" $ do
+  it "supports undo/redo" $ do
+    let executor = makeExecutor "Hello"
+        executor' = executeCommand executeTextCommand 
+                                  (InsertCommand 5 " World") executor
+        executor'' = undoCommand undoTextCommand executor'
+        executor''' = redoCommand executeTextCommand executor''
+    executorState executor' `shouldBe` "Hello World"
+    executorState executor'' `shouldBe` "Hello"
+    executorState executor''' `shouldBe` "Hello World"
+```
+
+## まとめ
+
+Command パターンの Haskell における実装のポイント：
+
+1. **ADT によるコマンド表現**: コマンドを代数的データ型で定義
+2. **純粋関数としての実行**: 状態を引数として受け取り、新しい状態を返す
+3. **履歴管理**: Undo/Redo スタックを不変データ構造で管理
+4. **合成可能性**: マクロコマンドによるコマンドの組み合わせ
+5. **型安全性**: 異なるドメインのコマンドを型で分離