@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/20-pattern-interactions.md

@@ -0,0 +1,323 @@
+# 第20章 パターンの相互作用 - 複合パターンの活用
+
+## 概要
+
+この章では、複数の関数型デザインパターンを組み合わせて、複雑な問題を解決する方法を学びます。ECサイトのショッピングカートシステムを例に、Strategy、Decorator、Command、Composite、Visitor パターンの統合を示します。
+
+## 学習目標
+
+- 複数パターンの効果的な組み合わせ方
+- パターン間の協調動作の設計
+- 実用的なシステムでのパターン適用
+- 関数型での柔軟なアーキテクチャ構築
+
+## 商品と価格設定
+
+### 商品の定義
+
+```haskell
+-- | 商品
+data Product = Product
+  { productId :: String
+  , productName :: String
+  , productBasePrice :: Double
+  , productCategory :: String
+  } deriving (Show, Eq)
+
+-- | 商品の作成
+makeProduct :: String -> String -> Double -> String -> Product
+makeProduct = Product
+```
+
+### 価格設定戦略 (Strategy パターン)
+
+```haskell
+-- | 価格設定戦略
+newtype PricingStrategy = PricingStrategy
+  { applyPricing :: Product -> Int -> Double
+  }
+
+-- | 通常価格
+regularPricing :: PricingStrategy
+regularPricing = PricingStrategy $ \prod qty ->
+  productBasePrice prod * fromIntegral qty
+
+-- | 割引価格
+discountPricing :: Double -> PricingStrategy
+discountPricing percent = PricingStrategy $ \prod qty ->
+  productBasePrice prod * fromIntegral qty * (1 - percent / 100)
+
+-- | まとめ買い価格
+bulkPricing :: Int -> Double -> PricingStrategy
+bulkPricing threshold percent = PricingStrategy $ \prod qty ->
+  let basePrice = productBasePrice prod * fromIntegral qty
+  in if qty >= threshold
+     then basePrice * (1 - percent / 100)
+     else basePrice
+```
+
+## 割引デコレータ (Decorator パターン)
+
+```haskell
+-- | 割引デコレータ
+type DiscountDecorator = Double -> Double
+
+-- | パーセント割引
+percentageDiscount :: Double -> DiscountDecorator
+percentageDiscount percent price = price * (1 - percent / 100)
+
+-- | 固定額割引
+fixedDiscount :: Double -> DiscountDecorator
+fixedDiscount amount price = max 0 (price - amount)
+
+-- | 季節割引
+seasonalDiscount :: Double -> DiscountDecorator
+seasonalDiscount multiplier price = price * multiplier
+
+-- | 複数割引の適用
+applyDiscounts :: [DiscountDecorator] -> Double -> Double
+applyDiscounts decorators price = foldl' (\p d -> d p) price decorators
+```
+
+## 注文コマンド (Command パターン)
+
+```haskell
+-- | 注文コマンド型クラス
+class OrderCommand cmd where
+  execute :: cmd -> ShoppingCart -> ShoppingCart
+
+-- | 商品追加コマンド
+data AddItem = AddItem Product Int
+
+instance OrderCommand AddItem where
+  execute (AddItem prod qty) cart =
+    let item = CartItem prod qty (productBasePrice prod)
+        newItems = item : scItems cart
+    in cart { scItems = newItems }
+
+-- | 商品削除コマンド
+data RemoveItem = RemoveItem String
+
+instance OrderCommand RemoveItem where
+  execute (RemoveItem prodId) cart =
+    let newItems = filter (\item -> productId (ciProduct item) /= prodId) (scItems cart)
+    in cart { scItems = newItems }
+
+-- | 割引適用コマンド
+data ApplyDiscount = ApplyDiscount DiscountDecorator
+
+instance OrderCommand ApplyDiscount where
+  execute (ApplyDiscount discount) cart =
+    cart { scDiscount = Just discount }
+```
+
+## ショッピングカート (Composite パターン)
+
+```haskell
+-- | カートアイテム
+data CartItem = CartItem
+  { ciProduct :: Product
+  , ciQuantity :: Int
+  , ciUnitPrice :: Double
+  } deriving (Show, Eq)
+
+-- | ショッピングカート
+data ShoppingCart = ShoppingCart
+  { scItems :: [CartItem]
+  , scDiscount :: Maybe DiscountDecorator
+  }
+
+-- | 空のカート
+emptyCart :: ShoppingCart
+emptyCart = ShoppingCart [] Nothing
+
+-- | カート合計
+cartTotal :: ShoppingCart -> Double
+cartTotal cart =
+  let subtotal = sum [ciUnitPrice item * fromIntegral (ciQuantity item) 
+                     | item <- scItems cart]
+  in case scDiscount cart of
+       Nothing -> subtotal
+       Just discount -> discount subtotal
+```
+
+## 注文処理パイプライン
+
+```haskell
+-- | 注文処理結果
+data OrderResult
+  = OrderSuccess ShoppingCart
+  | OrderFailure String
+
+-- | パイプラインステップ
+type OrderPipeline = ShoppingCart -> OrderResult
+
+-- | 検証ステップ
+validationStep :: OrderPipeline
+validationStep cart =
+  if null (scItems cart)
+  then OrderFailure "Cart is empty"
+  else OrderSuccess cart
+
+-- | 割引ステップ
+discountStep :: Double -> OrderPipeline
+discountStep percent cart =
+  OrderSuccess cart { scDiscount = Just (percentageDiscount percent) }
+
+-- | パイプライン実行
+runPipeline :: [OrderPipeline] -> ShoppingCart -> OrderResult
+runPipeline [] cart = OrderSuccess cart
+runPipeline (step:steps) cart =
+  case step cart of
+    OrderFailure msg -> OrderFailure msg
+    OrderSuccess cart' -> runPipeline steps cart'
+```
+
+## カート分析ビジター (Visitor パターン)
+
+```haskell
+-- | カートビジター
+newtype CartVisitor a = CartVisitor
+  { runVisitor :: ShoppingCart -> a
+  }
+
+-- | アイテム数カウント
+itemCountVisitor :: CartVisitor Int
+itemCountVisitor = CartVisitor $ \cart ->
+  sum [ciQuantity item | item <- scItems cart]
+
+-- | 合計金額
+totalValueVisitor :: CartVisitor Double
+totalValueVisitor = CartVisitor cartTotal
+
+-- | 平均単価
+averageItemPriceVisitor :: CartVisitor Double
+averageItemPriceVisitor = CartVisitor $ \cart ->
+  let items = scItems cart
+      count = length items
+  in if count == 0
+     then 0
+     else sum [ciUnitPrice item | item <- items] / fromIntegral count
+
+-- | ビジターの適用
+visitCart :: CartVisitor a -> ShoppingCart -> a
+visitCart visitor cart = runVisitor visitor cart
+```
+
+## 使用例
+
+### 完全な注文フロー
+
+```haskell
+-- 商品の定義
+laptop = makeProduct "P001" "Laptop" 1000.0 "Electronics"
+mouse = makeProduct "P002" "Mouse" 50.0 "Electronics"
+
+-- コマンドを使ってカートを構築
+cart1 = executeCommand (AddItem laptop 1) emptyCart
+cart2 = executeCommand (AddItem mouse 2) cart1
+cart3 = executeCommand (ApplyDiscount (percentageDiscount 5)) cart2
+
+-- パイプラインで処理
+pipeline = [validationStep]
+result = runPipeline pipeline cart3
+
+-- ビジターで分析
+case result of
+  OrderSuccess cart -> do
+    putStrLn $ "Items: " ++ show (visitCart itemCountVisitor cart)
+    putStrLn $ "Total: $" ++ show (visitCart totalValueVisitor cart)
+  OrderFailure msg -> putStrLn $ "Error: " ++ msg
+
+-- 出力:
+-- Items: 3
+-- Total: $1045.0 (1100 * 0.95)
+```
+
+### パターンの協調
+
+```haskell
+-- Strategy: 価格戦略を選択
+strategy = if isBulkOrder then bulkPricing 10 15 else regularPricing
+
+-- Decorator: 割引を積み重ね
+discounts = [percentageDiscount 10, fixedDiscount 50]
+finalPrice = applyDiscounts discounts basePrice
+
+-- Command: 操作をデータ化
+commands = [AddItem prod1 1, AddItem prod2 2, ApplyDiscount (percentageDiscount 5)]
+cart = foldl (\c cmd -> executeCommand cmd c) emptyCart commands
+
+-- Visitor: カートを分析
+stats = (visitCart itemCountVisitor cart, visitCart totalValueVisitor cart)
+```
+
+## テスト
+
+```haskell
+spec :: Spec
+spec = do
+  describe "Pattern Integration" $ do
+    it "processes complete order with multiple patterns" $ do
+      let product1 = makeProduct "P001" "Laptop" 1000.0 "Electronics"
+          product2 = makeProduct "P002" "Mouse" 50.0 "Electronics"
+          
+          -- コマンドでカートを構築
+          cart1 = executeCommand (AddItem product1 1) emptyCart
+          cart2 = executeCommand (AddItem product2 2) cart1
+          cart3 = executeCommand (ApplyDiscount (percentageDiscount 5)) cart2
+          
+          -- パイプラインで処理
+          pipeline' = [validationStep]
+      
+      case runPipeline pipeline' cart3 of
+        OrderSuccess cart' -> do
+          visitCart itemCountVisitor cart' `shouldBe` 3
+          cartTotal cart' `shouldBe` 1045.0
+        OrderFailure _ -> expectationFailure "Order should succeed"
+```
+
+## パターン組み合わせの原則
+
+### 1. 責任の分離
+
+各パターンは単一の責任を持つ：
+- Strategy: 価格計算方法
+- Decorator: 価格修飾
+- Command: 操作のカプセル化
+- Composite: 構造の管理
+- Visitor: 横断的な処理
+
+### 2. 合成可能性
+
+パターンは互いに干渉せず、組み合わせ可能：
+
+```haskell
+-- どのパターンも独立して使用可能
+price1 = applyPricing regularPricing product 1
+price2 = percentageDiscount 10 price1
+cart = executeCommand (AddItem product 1) emptyCart
+count = visitCart itemCountVisitor cart
+```
+
+### 3. 型による安全性
+
+型システムが不正な組み合わせを防止：
+
+```haskell
+-- 型クラスで操作を統一
+class OrderCommand cmd where
+  execute :: cmd -> ShoppingCart -> ShoppingCart
+
+-- 新しいコマンドの追加が安全
+data NewCommand = ...
+instance OrderCommand NewCommand where
+  execute = ...
+```
+
+## まとめ
+
+- 複数のパターンを組み合わせることで、複雑な問題を分割統治できる
+- 各パターンは独立して進化・テスト可能
+- 関数型アプローチにより、パターンの合成が自然になる
+- 型システムにより、安全なパターンの組み合わせが保証される

package/lib/assets/docs/article/functional-desgin-ppp/haskell/21-best-practices.md

@@ -0,0 +1,403 @@
+# 第21章 関数型プログラミングのベストプラクティス
+
+## 概要
+
+この章では、Haskell での関数型プログラミングにおけるベストプラクティスを学びます。不変性、関数合成、純粋関数、エラーハンドリング、型安全性などの重要な原則を実践的に示します。
+
+## 学習目標
+
+- 不変性を活用したコード設計
+- 関数合成によるパイプライン構築
+- 純粋関数と参照透過性の維持
+- 安全なエラーハンドリング
+- 型システムによる堅牢性向上
+
+## 不変性の実践
+
+### レコードの不変更新
+
+```haskell
+-- | ユーザーレコード
+data User = User
+  { userName :: String
+  , userEmail :: String
+  , userAge :: Int
+  } deriving (Show, Eq)
+
+-- | 名前の更新（元のデータは変更しない）
+updateUserName :: String -> User -> User
+updateUserName newName user = user { userName = newName }
+
+-- | メールの更新
+updateUserEmail :: String -> User -> User
+updateUserEmail newEmail user = user { userEmail = newEmail }
+
+-- | 年齢の更新
+updateUserAge :: Int -> User -> User
+updateUserAge newAge user = user { userAge = newAge }
+
+-- 使用例
+let alice = User "Alice" "alice@example.com" 30
+let bob = updateUserName "Bob" alice
+-- alice は変更されない
+-- bob は新しい User
+```
+
+### 汎用更新関数
+
+```haskell
+-- | 任意の更新関数を適用
+updateUser :: (User -> User) -> User -> User
+updateUser f = f
+
+-- 複数の更新を合成
+updateAll :: User -> User
+updateAll = updateUserName "Charlie" 
+          . updateUserEmail "charlie@example.com"
+          . updateUserAge 25
+```
+
+## 関数合成
+
+### パイプライン演算子
+
+```haskell
+-- | 前方パイプ
+(|>) :: a -> (a -> b) -> b
+x |> f = f x
+infixl 1 |>
+
+-- | 後方パイプ
+(<|) :: (a -> b) -> a -> b
+f <| x = f x
+infixr 0 <|
+
+-- 使用例
+result = "  HELLO WORLD  "
+       |> trim
+       |> toLowerCase
+       |> removeSpaces
+-- "helloworld"
+```
+
+### 関数のパイプライン化
+
+```haskell
+-- | パイプラインの作成
+pipeline :: [a -> a] -> a -> a
+pipeline = foldl' (flip (.)) id
+
+-- 使用例
+sanitize = pipeline [trim, toLowerCase, removeSpaces]
+result = sanitize "  Hello World  "  -- "helloworld"
+```
+
+### 文字列変換関数
+
+```haskell
+-- | 空白のトリム
+trim :: String -> String
+trim = dropWhile isSpace . reverse . dropWhile isSpace . reverse
+
+-- | 小文字化
+toLowerCase :: String -> String
+toLowerCase = map toLower
+
+-- | 空白除去
+removeSpaces :: String -> String
+removeSpaces = filter (not . isSpace)
+
+-- | 入力のサニタイズ
+sanitizeInput :: String -> String
+sanitizeInput = toLowerCase . trim
+```
+
+## 純粋関数
+
+### 参照透過性
+
+```haskell
+-- | 純粋な加算
+pureAdd :: Num a => a -> a -> a
+pureAdd x y = x + y
+
+-- | 純粋な乗算
+pureMultiply :: Num a => a -> a -> a
+pureMultiply x y = x * y
+
+-- | 純粋な計算
+pureCompute :: Int -> Int -> Int -> Int
+pureCompute x y z = (x + y) * z
+
+-- 同じ入力には常に同じ出力
+pureCompute 2 3 4  -- 常に 20
+pureCompute 2 3 4  -- 常に 20
+```
+
+### 副作用の分離
+
+```haskell
+-- | 計算の抽象化
+data Computation a
+  = Pure a
+  | Effect (IO a)
+
+instance Functor Computation where
+  fmap f (Pure a) = Pure (f a)
+  fmap f (Effect io) = Effect (fmap f io)
+
+-- | 純粋な計算ステップ
+pureStep :: a -> Computation a
+pureStep = Pure
+
+-- | 計算の実行
+runComputation :: Computation a -> IO a
+runComputation (Pure a) = return a
+runComputation (Effect io) = io
+```
+
+## エラーハンドリング
+
+### Result 型
+
+```haskell
+-- | 結果型
+data Result e a
+  = Success a
+  | Failure e
+  deriving (Show, Eq)
+
+-- | 結果のマップ
+mapResult :: (a -> b) -> Result e a -> Result e b
+mapResult f (Success a) = Success (f a)
+mapResult _ (Failure e) = Failure e
+
+-- | 結果のフラットマップ
+flatMapResult :: (a -> Result e b) -> Result e a -> Result e b
+flatMapResult f (Success a) = f a
+flatMapResult _ (Failure e) = Failure e
+
+-- | Maybe から Result への変換
+fromMaybe' :: e -> Maybe a -> Result e a
+fromMaybe' _ (Just a) = Success a
+fromMaybe' e Nothing = Failure e
+```
+
+### バリデーション
+
+```haskell
+-- | バリデーション結果
+data Validation e a
+  = Valid a
+  | Invalid [e]
+  deriving (Show, Eq)
+
+-- | 単一のバリデーション
+validate :: (a -> Bool) -> e -> a -> Validation e a
+validate predicate err value =
+  if predicate value
+  then Valid value
+  else Invalid [err]
+
+-- | 複数ルールのバリデーション
+validateAll :: [(a -> Bool, e)] -> a -> Validation e a
+validateAll rules value =
+  let errors = [err | (predicate, err) <- rules, not (predicate value)]
+  in if null errors
+     then Valid value
+     else Invalid errors
+
+-- 使用例
+validateAge :: Int -> Validation String Int
+validateAge = validateAll 
+  [ ((>= 0), "Age must be non-negative")
+  , ((<= 150), "Age must be realistic")
+  ]
+
+validateAge 25   -- Valid 25
+validateAge (-5) -- Invalid ["Age must be non-negative"]
+validateAge 200  -- Invalid ["Age must be realistic"]
+```
+
+### バリデーションの合成
+
+```haskell
+-- | 複数バリデーションの結合
+combineValidations :: [Validation e a] -> Validation e [a]
+combineValidations validations =
+  let (valids, invalids) = partitionValidations validations
+  in if null invalids
+     then Valid valids
+     else Invalid (concat invalids)
+
+-- 使用例
+let v1 = validate (> 0) "must be positive" 5
+    v2 = validate (< 100) "must be < 100" 50
+combineValidations [v1, v2]  -- Valid [5, 50]
+```
+
+## データ変換
+
+### Map/Filter/Reduce
+
+```haskell
+-- | マップ
+mapOver :: (a -> b) -> [a] -> [b]
+mapOver = map
+
+-- | フィルター
+filterBy :: (a -> Bool) -> [a] -> [a]
+filterBy = filter
+
+-- | リデュース
+reduceWith :: (b -> a -> b) -> b -> [a] -> b
+reduceWith = foldl'
+
+-- | 変換パイプライン
+transformPipeline :: (a -> b) -> (b -> Bool) -> (c -> b -> c) -> c -> [a] -> c
+transformPipeline mapF filterF reduceF initial xs =
+  reduceWith reduceF initial (filterBy filterF (mapOver mapF xs))
+
+-- 使用例：偶数を2倍して合計
+result = transformPipeline (*2) even (+) 0 [1..5]  -- 12
+```
+
+### 遅延評価
+
+```haskell
+-- | 遅延レンジ
+lazyRange :: Int -> Int -> [Int]
+lazyRange start end = [start..end]
+
+-- | 条件付き取得
+takeWhile' :: (a -> Bool) -> [a] -> [a]
+takeWhile' = takeWhile
+
+-- | 無限シーケンス
+infiniteSequence :: a -> (a -> a) -> [a]
+infiniteSequence start next = iterate next start
+
+-- 使用例
+take 5 (infiniteSequence 1 (+1))   -- [1, 2, 3, 4, 5]
+take 5 (infiniteSequence 2 (*2))   -- [2, 4, 8, 16, 32]
+takeWhile' (< 100) (infiniteSequence 1 (*2))  -- [1, 2, 4, 8, 16, 32, 64]
+```
+
+## 型安全性
+
+### Newtype パターン
+
+```haskell
+-- | Email newtype
+newtype Email = Email { unEmail :: String }
+  deriving (Show, Eq)
+
+-- | スマートコンストラクタ
+mkEmail :: String -> Maybe Email
+mkEmail s
+  | '@' `elem` s && '.' `elem` dropWhile (/= '@') s = Just (Email s)
+  | otherwise = Nothing
+
+-- | Username newtype
+newtype Username = Username { unUsername :: String }
+  deriving (Show, Eq)
+
+mkUsername :: String -> Maybe Username
+mkUsername s
+  | length s >= 3 && length s <= 20 = Just (Username s)
+  | otherwise = Nothing
+
+-- | Age newtype
+newtype Age = Age { unAge :: Int }
+  deriving (Show, Eq)
+
+mkAge :: Int -> Maybe Age
+mkAge n
+  | n >= 0 && n <= 150 = Just (Age n)
+  | otherwise = Nothing
+```
+
+### 正の整数
+
+```haskell
+-- | 正の整数
+newtype PositiveInt = PositiveInt { unPositiveInt :: Int }
+  deriving (Show, Eq)
+
+mkPositiveInt :: Int -> Maybe PositiveInt
+mkPositiveInt n
+  | n > 0 = Just (PositiveInt n)
+  | otherwise = Nothing
+
+-- | 空でない文字列
+newtype NonEmptyString = NonEmptyString { unNonEmptyString :: String }
+  deriving (Show, Eq)
+
+mkNonEmptyString :: String -> Maybe NonEmptyString
+mkNonEmptyString s
+  | null s = Nothing
+  | otherwise = Just (NonEmptyString s)
+```
+
+## テストのベストプラクティス
+
+### 代数的性質のテスト
+
+```haskell
+-- | 結合律のテスト
+associative :: Eq a => (a -> a -> a) -> a -> a -> a -> Bool
+associative f a b c = f (f a b) c == f a (f b c)
+
+-- | 交換律のテスト
+commutative :: Eq b => (a -> a -> b) -> a -> a -> Bool
+commutative f a b = f a b == f b a
+
+-- | 単位元のテスト
+identity' :: Eq a => (a -> a -> a) -> a -> a -> Bool
+identity' f identity a = f a identity == a && f identity a == a
+
+-- | 逆元のテスト
+inverse :: Eq a => (a -> a -> a) -> (a -> a) -> a -> a -> Bool
+inverse f inv identity a = f a (inv a) == identity
+```
+
+### プロパティベーステスト
+
+```haskell
+spec :: Spec
+spec = do
+  it "addition is associative" $ property $
+    \(x :: Int) y z -> associative (+) x y z
+
+  it "addition is commutative" $ property $
+    \(x :: Int) y -> commutative (+) x y
+
+  it "0 is identity for addition" $ property $
+    \(x :: Int) -> identity' (+) 0 x
+```
+
+## まとめ
+
+### 不変性の利点
+
+- 予測可能な動作
+- 並行処理の安全性
+- デバッグの容易さ
+
+### 関数合成の利点
+
+- コードの再利用性
+- 読みやすいパイプライン
+- テストの容易さ
+
+### 型安全性の利点
+
+- コンパイル時のエラー検出
+- 不正な状態の防止
+- ドキュメントとしての型
+
+### エラーハンドリングの原則
+
+- 例外より戻り値
+- 型でエラーを表現
+- バリデーションの合成