@k2works/claude-code-booster 6.2.0 → 6.3.0

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

@@ -1,296 +0,0 @@
----
-type: Article
-title: "第10章: Strategy パターン"
-description: "Strategy パターンは、アルゴリズムを個別に定義し、それらを交換可能にするパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,312 +0,0 @@
----
-type: Article
-title: "第11章: Command パターン"
-description: "Command パターンは、リクエストをオブジェクトとしてカプセル化し、異なるリクエストでクライアントをパラメータ化したり、リクエストをキューに入れたり、操作の履歴を記録したりすることができるパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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. **型安全性**: 異なるドメインのコマンドを型で分離