@k2works/claude-code-booster 2.7.1 → 3.1.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/08-decorator-pattern.md

@@ -0,0 +1,319 @@
+# 第8章: Decorator パターン
+
+## はじめに
+
+Decorator パターンは、既存のオブジェクトに新しい機能を動的に追加するパターンです。このパターンを使用すると、サブクラス化による継承よりも柔軟な方法で機能を拡張できます。
+
+関数型プログラミングでは、高階関数を使って関数をラップし、横断的関心事（ログ、キャッシュ、認証など）を追加します。本章では、形状のジャーナリングと関数デコレータについて学びます。
+
+## 1. パターンの構造
+
+Decorator パターンは以下の要素で構成されます：
+
+- **Component**: デコレート対象の共通インターフェース
+- **ConcreteComponent**: 具体的なコンポーネント
+- **Decorator**: Component をラップし、追加機能を提供
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+interface Component {
+  +operation()
+}
+
+class ConcreteComponent {
+  +operation()
+}
+
+class Decorator {
+  +wrapped: Component
+  +operation()
+}
+
+Component <|.. ConcreteComponent
+Component <|.. Decorator
+Decorator o--> Component : wraps
+@enduml
+```
+
+## 2. JournaledShape の例
+
+### データ型の定義
+
+形状オブジェクトに操作の履歴を記録する機能を追加するデコレータです。
+
+```haskell
+-- | Journal entry for shape operations
+data JournalEntry
+  = TranslateEntry Double Double  -- ^ Translation by (dx, dy)
+  | ScaleEntry Double             -- ^ Scale by factor
+  deriving (Show, Eq)
+
+-- | Shape with operation history
+data JournaledShape = JournaledShape
+  { jsJournal :: [JournalEntry]   -- ^ History of operations
+  , jsShape :: Shape              -- ^ The wrapped shape
+  } deriving (Show, Eq)
+
+-- | Wrap a shape with journaling
+journalShape :: Shape -> JournaledShape
+journalShape shape = JournaledShape
+  { jsJournal = []
+  , jsShape = shape
+  }
+
+-- | Get the journal entries
+getJournal :: JournaledShape -> [JournalEntry]
+getJournal = jsJournal
+
+-- | Get the underlying shape
+getShape :: JournaledShape -> Shape
+getShape = jsShape
+```
+
+### デコレートされた操作
+
+```haskell
+-- | Translate a journaled shape
+translateJournaled :: Double -> Double -> JournaledShape -> JournaledShape
+translateJournaled dx dy js = JournaledShape
+  { jsJournal = jsJournal js ++ [TranslateEntry dx dy]
+  , jsShape = translateShape dx dy (jsShape js)
+  }
+
+-- | Scale a journaled shape
+scaleJournaled :: Double -> JournaledShape -> JournaledShape
+scaleJournaled factor js = JournaledShape
+  { jsJournal = jsJournal js ++ [ScaleEntry factor]
+  , jsShape = scaleShape factor (jsShape js)
+  }
+```
+
+### 使用例
+
+```haskell
+-- 形状をデコレート
+let journaledSquare = journalShape (Square (Point 0 0) 1)
+                    & translateJournaled 2 3
+                    & scaleJournaled 5
+
+-- ジャーナルを確認
+getJournal journaledSquare
+-- [TranslateEntry 2 3, ScaleEntry 5]
+
+-- 実際の形状を確認
+getShape journaledSquare
+-- Square (Point 2 3) 5
+```
+
+## 3. 関数デコレータ
+
+関数型プログラミングでは、高階関数を使って関数をデコレートします。
+
+### ログ出力デコレータ
+
+```haskell
+-- | Add logging to a function (collects log entries)
+withLogging :: String -> (a -> b) -> (a -> (b, [String]))
+withLogging name f = \x -> 
+  let result = f x
+  in (result, ["[LOG] " ++ name ++ " called", "[LOG] " ++ name ++ " returned"])
+
+-- 使用例
+let addLogged = withLogging "double" (* 2)
+let (result, logs) = addLogged 5
+-- result = 10
+-- logs = ["[LOG] double called", "[LOG] double returned"]
+```
+
+### リトライデコレータ
+
+```haskell
+-- | Add retry logic to a function that might fail
+withRetry :: Int -> (a -> Either String b) -> (a -> Either String b)
+withRetry maxRetries f = go 0
+  where
+    go attempts x
+      | attempts >= maxRetries = Left "Max retries exceeded"
+      | otherwise = case f x of
+          Right result -> Right result
+          Left _ -> go (attempts + 1) x
+
+-- 使用例
+let unreliable _ = Left "error" :: Either String String
+let withRetries = withRetry 3 unreliable
+withRetries ()  -- Left "Max retries exceeded"
+```
+
+### キャッシュデコレータ
+
+```haskell
+-- | Add caching to a function (using a Map for pure memoization)
+withCache :: Ord a => (a -> b) -> (Map a b -> a -> (b, Map a b))
+withCache f = \cache x ->
+  case Map.lookup x cache of
+    Just cached -> (cached, cache)
+    Nothing -> 
+      let result = f x
+      in (result, Map.insert x result cache)
+
+-- 使用例
+let expensiveFn x = x * x  -- expensive computation
+let cached = withCache expensiveFn
+let (result1, cache1) = cached Map.empty 5    -- computes
+let (result2, cache2) = cached cache1 5       -- cache hit
+```
+
+### バリデーションデコレータ
+
+```haskell
+-- | Add validation to a function
+withValidation :: (a -> Bool) -> String -> (a -> Either String b) -> (a -> Either String b)
+withValidation validator errMsg f = \x ->
+  if validator x
+    then f x
+    else Left errMsg
+
+-- 使用例
+let positiveOnly = withValidation (> 0) "Must be positive" (\x -> Right (x * 2))
+positiveOnly 5   -- Right 10
+positiveOnly (-5) -- Left "Must be positive"
+```
+
+## 4. デコレータの組み合わせ
+
+複数のデコレータを組み合わせて使用できます。
+
+```haskell
+-- | Compose multiple function transformations
+composeDecorators :: [a -> a] -> a -> a
+composeDecorators = foldr (.) id
+
+-- 使用例
+let add1 = (+ 1) :: Int -> Int
+let mul2 = (* 2)
+let decorators = [add1, mul2]  -- (x * 2) + 1
+let composed = composeDecorators decorators
+composed 5  -- 11 = (5 * 2) + 1
+```
+
+### 組み合わせのシーケンス図
+
+```plantuml
+@startuml
+actor Client
+participant "withLogging" as logging
+participant "withCache" as cache
+participant "base-fn" as base
+
+Client -> logging : call(args)
+activate logging
+logging -> logging : log "called with args"
+
+logging -> cache : call(args)
+activate cache
+
+alt キャッシュヒット
+  cache -> cache : return cached value
+else キャッシュミス
+  cache -> base : call(args)
+  activate base
+  base --> cache : result
+  deactivate base
+  cache -> cache : store in cache
+end
+
+cache --> logging : result
+deactivate cache
+
+logging -> logging : log "returned result"
+logging --> Client : result
+deactivate logging
+
+note right
+  デコレータは外側から内側へ
+  順番に適用されます
+end note
+@enduml
+```
+
+## 5. カウンタ付き操作
+
+```haskell
+-- | Result with call count
+data CountedResult a = CountedResult
+  { crResult :: a
+  , crCount :: Int
+  } deriving (Show, Eq)
+
+-- | Wrap a function to count calls
+withCounter :: (a -> b) -> ([a] -> [CountedResult b])
+withCounter f = zipWith (\i x -> CountedResult (f x) i) [1..]
+
+-- 使用例
+let counted = withCounter (* 2)
+counted [1, 2, 3]
+-- [CountedResult 2 1, CountedResult 4 2, CountedResult 6 3]
+```
+
+## 6. パターンの利点
+
+1. **単一責任の原則**: 各デコレータは一つの機能のみを追加
+2. **開放/閉鎖の原則**: 既存コードを変更せずに機能を追加
+3. **柔軟な組み合わせ**: 必要な機能だけを選択して組み合わせ可能
+4. **実行時の決定**: どのデコレータを適用するか実行時に決定可能
+
+## 7. Haskell での特徴
+
+Haskell での Decorator パターンの実装には以下の特徴があります：
+
+1. **高階関数**: 関数を引数に取り、新しい関数を返す
+2. **純粋性**: 副作用を避け、状態はデータ構造で明示的に管理
+3. **イミュータブルなデータ**: デコレート後も元のデータは変更されない
+4. **合成のしやすさ**: `(.)` 演算子や `foldr` で簡単に組み合わせ可能
+5. **型安全性**: 型システムによりデコレータの適用ミスを防止
+
+### Haskell 特有の考慮事項
+
+```haskell
+-- Haskell では副作用を持つ操作は IO モナドを使用
+-- 純粋なデコレータでは状態を明示的に渡す必要がある
+
+-- 純粋なキャッシュ（状態を明示的に渡す）
+withCache :: Ord a => (a -> b) -> (Map a b -> a -> (b, Map a b))
+
+-- IO モナドを使ったキャッシュ（内部状態を持つ）
+withCacheIO :: Ord a => (a -> b) -> IO (a -> IO b)
+withCacheIO f = do
+  ref <- newIORef Map.empty
+  return $ \x -> do
+    cache <- readIORef ref
+    case Map.lookup x cache of
+      Just v -> return v
+      Nothing -> do
+        let v = f x
+        modifyIORef ref (Map.insert x v)
+        return v
+```
+
+## まとめ
+
+本章では、Decorator パターンについて学びました：
+
+1. **JournaledShape**: 形状操作の履歴を記録するデコレータ
+2. **関数デコレータ**: ログ、リトライ、キャッシュなどの横断的関心事
+3. **デコレータの組み合わせ**: 複数のデコレータを柔軟に組み合わせ
+
+Decorator パターンは、既存のコードを変更せずに機能を拡張する強力なパターンです。Haskell では高階関数と純粋関数を活用することで、型安全で合成しやすいデコレータを実装できます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/haskell/part3/src/DecoratorPattern.hs`
+- テストコード: `apps/haskell/part3/test/DecoratorPatternSpec.hs`
+
+## 次章予告
+
+次章では、**Adapter パターン**について学びます。異なるインターフェース間の変換とレガシーシステムとの統合を探ります。

package/lib/assets/docs/article/functional-desgin-ppp/haskell/09-adapter-pattern.md

@@ -0,0 +1,382 @@
+# 第9章: Adapter パターン
+
+## はじめに
+
+Adapter パターンは、既存のクラスのインターフェースを、クライアントが期待する別のインターフェースに変換するパターンです。このパターンを使用すると、互換性のないインターフェースを持つクラス同士を連携させることができます。
+
+本章では、可変強度ライトのアダプター、データフォーマット変換、温度・通貨変換について学びます。
+
+## 1. パターンの構造
+
+Adapter パターンは以下の要素で構成されます：
+
+- **Target**: クライアントが期待するインターフェース
+- **Adaptee**: 既存のクラス（適応される側）
+- **Adapter**: Target インターフェースを実装し、Adaptee を使用
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+interface Target {
+  +request()
+}
+
+class Adaptee {
+  +specificRequest()
+}
+
+class Adapter {
+  +adaptee: Adaptee
+  +request()
+}
+
+class Client {
+  +operation()
+}
+
+Adapter ..|> Target
+Adapter --> Adaptee : adapts
+Client --> Target : uses
+@enduml
+```
+
+## 2. VariableLight の例
+
+### Switchable インターフェース (Target)
+
+```haskell
+-- | Result of a switch operation
+data SwitchResult = SwitchResult
+  { srOn :: Bool
+  , srIntensity :: Maybe Int
+  } deriving (Show, Eq)
+
+-- | Switchable interface - the target interface
+class Switchable a where
+  switchTurnOn :: a -> (a, SwitchResult)
+  switchTurnOff :: a -> (a, SwitchResult)
+```
+
+### VariableLight (Adaptee)
+
+可変強度を持つライトは、単純なオン/オフではなく、強度を指定する必要があります。
+
+```haskell
+-- | Variable light with intensity control
+data VariableLight = VariableLight
+  { vlIntensity :: Int  -- ^ 0-100
+  } deriving (Show, Eq)
+
+-- | Set the light intensity (the adaptee's specific method)
+setLightIntensity :: Int -> VariableLight -> VariableLight
+setLightIntensity intensity vl = vl { vlIntensity = max 0 (min 100 intensity) }
+```
+
+### VariableLightAdapter (Adapter)
+
+```haskell
+-- | Adapter that wraps VariableLight and provides Switchable interface
+data VariableLightAdapter = VariableLightAdapter
+  { vlaLight :: VariableLight
+  , vlaMinIntensity :: Int
+  , vlaMaxIntensity :: Int
+  } deriving (Show, Eq)
+
+-- | Create a variable light adapter
+makeVariableLightAdapter :: Int -> Int -> VariableLightAdapter
+makeVariableLightAdapter minI maxI = VariableLightAdapter
+  { vlaLight = VariableLight 0
+  , vlaMinIntensity = minI
+  , vlaMaxIntensity = maxI
+  }
+
+-- | Turn on through the adapter
+adaptedTurnOn :: VariableLightAdapter -> (VariableLightAdapter, SwitchResult)
+adaptedTurnOn adapter =
+  let newLight = setLightIntensity (vlaMaxIntensity adapter) (vlaLight adapter)
+      newAdapter = adapter { vlaLight = newLight }
+      result = SwitchResult True (Just $ vlIntensity newLight)
+  in (newAdapter, result)
+
+-- | Turn off through the adapter
+adaptedTurnOff :: VariableLightAdapter -> (VariableLightAdapter, SwitchResult)
+adaptedTurnOff adapter =
+  let newLight = setLightIntensity (vlaMinIntensity adapter) (vlaLight adapter)
+      newAdapter = adapter { vlaLight = newLight }
+      result = SwitchResult False (Just $ vlIntensity newLight)
+  in (newAdapter, result)
+
+-- Make VariableLightAdapter an instance of Switchable
+instance Switchable VariableLightAdapter where
+  switchTurnOn = adaptedTurnOn
+  switchTurnOff = adaptedTurnOff
+```
+
+### 使用例
+
+```haskell
+-- アダプターを作成（最小0、最大100）
+let adapter = makeVariableLightAdapter 0 100
+
+-- クライアントはSwitchableインターフェースで操作
+let (onAdapter, onResult) = switchTurnOn adapter
+-- onResult = SwitchResult True (Just 100)
+
+let (offAdapter, offResult) = switchTurnOff onAdapter
+-- offResult = SwitchResult False (Just 0)
+```
+
+## 3. データフォーマットアダプター
+
+### ユーザーフォーマット変換
+
+異なるシステム間でデータフォーマットが異なる場合、アダプターを使って変換します。
+
+```haskell
+-- | Old user format (legacy system)
+data OldUserFormat = OldUserFormat
+  { oufFirstName :: String
+  , oufLastName :: String
+  , oufEmailAddress :: String
+  , oufPhoneNumber :: String
+  } deriving (Show, Eq)
+
+-- | Metadata for converted users
+data UserMetadata = UserMetadata
+  { umMigrated :: Bool
+  , umOriginalFormat :: String
+  } deriving (Show, Eq)
+
+-- | New user format (modern system)
+data NewUserFormat = NewUserFormat
+  { nufName :: String
+  , nufEmail :: String
+  , nufPhone :: String
+  , nufMetadata :: Maybe UserMetadata
+  } deriving (Show, Eq)
+
+-- | Adapt old user format to new format
+adaptOldToNew :: OldUserFormat -> NewUserFormat
+adaptOldToNew old = NewUserFormat
+  { nufName = oufLastName old ++ " " ++ oufFirstName old
+  , nufEmail = oufEmailAddress old
+  , nufPhone = oufPhoneNumber old
+  , nufMetadata = Just UserMetadata
+      { umMigrated = True
+      , umOriginalFormat = "old"
+      }
+  }
+
+-- | Adapt new user format to old format
+adaptNewToOld :: NewUserFormat -> OldUserFormat
+adaptNewToOld new =
+  case nonEmpty (words (nufName new)) of
+    Nothing -> OldUserFormat "" "" (nufEmail new) (nufPhone new)
+    Just ne -> OldUserFormat
+      { oufFirstName = unwords (NE.tail ne)
+      , oufLastName = NE.head ne
+      , oufEmailAddress = nufEmail new
+      , oufPhoneNumber = nufPhone new
+      }
+```
+
+### 使用例
+
+```haskell
+-- 旧フォーマット → 新フォーマット
+let oldUser = OldUserFormat "Taro" "Yamada" "taro@example.com" "090-1234-5678"
+let newUser = adaptOldToNew oldUser
+-- newUser = NewUserFormat 
+--   { nufName = "Yamada Taro"
+--   , nufEmail = "taro@example.com"
+--   , nufPhone = "090-1234-5678"
+--   , nufMetadata = Just UserMetadata {umMigrated = True, umOriginalFormat = "old"}
+--   }
+
+-- 新フォーマット → 旧フォーマット
+let back = adaptNewToOld newUser
+-- back = OldUserFormat "Taro" "Yamada" "taro@example.com" "090-1234-5678"
+```
+
+## 4. 温度アダプター
+
+```haskell
+-- | Temperature in Celsius
+newtype Celsius = Celsius { getCelsius :: Double }
+  deriving (Show, Eq)
+
+-- | Temperature in Fahrenheit
+newtype Fahrenheit = Fahrenheit { getFahrenheit :: Double }
+  deriving (Show, Eq)
+
+-- | Convert Celsius to Fahrenheit
+celsiusToFahrenheit :: Celsius -> Fahrenheit
+celsiusToFahrenheit (Celsius c) = Fahrenheit (c * 9/5 + 32)
+
+-- | Convert Fahrenheit to Celsius
+fahrenheitToCelsius :: Fahrenheit -> Celsius
+fahrenheitToCelsius (Fahrenheit f) = Celsius ((f - 32) * 5/9)
+```
+
+### 使用例
+
+```haskell
+let freezing = Celsius 0
+let boiling = Celsius 100
+
+celsiusToFahrenheit freezing  -- Fahrenheit 32
+celsiusToFahrenheit boiling   -- Fahrenheit 212
+
+-- 往復変換
+let temp = Celsius 25
+let converted = fahrenheitToCelsius (celsiusToFahrenheit temp)
+-- converted ≈ Celsius 25
+```
+
+## 5. 通貨アダプター
+
+```haskell
+-- | US Dollars
+newtype USD = USD { getUsd :: Double }
+  deriving (Show, Eq)
+
+-- | Euros
+newtype EUR = EUR { getEur :: Double }
+  deriving (Show, Eq)
+
+-- | Japanese Yen
+newtype JPY = JPY { getJpy :: Double }
+  deriving (Show, Eq)
+
+-- | Convert USD to EUR (simplified rate)
+convertUsdToEur :: USD -> EUR
+convertUsdToEur (USD usd) = EUR (usd * 0.85)
+
+-- | Convert USD to JPY (simplified rate)
+convertUsdToJpy :: USD -> JPY
+convertUsdToJpy (USD usd) = JPY (usd * 110)
+
+-- | Convert EUR to USD
+convertEurToUsd :: EUR -> USD
+convertEurToUsd (EUR eur) = USD (eur / 0.85)
+
+-- | Convert JPY to USD
+convertJpyToUsd :: JPY -> USD
+convertJpyToUsd (JPY jpy) = USD (jpy / 110)
+```
+
+## 6. 汎用アダプター
+
+```haskell
+-- | Generic bidirectional adapter
+data Adapter a b = Adapter
+  { adapterTo :: a -> b    -- ^ Convert from A to B
+  , adapterFrom :: b -> a  -- ^ Convert from B to A
+  }
+
+-- | Apply adapter to convert from A to B
+adapt :: Adapter a b -> a -> b
+adapt = adapterTo
+
+-- | Apply adapter to convert from B to A
+adaptBack :: Adapter a b -> b -> a
+adaptBack = adapterFrom
+```
+
+### 使用例
+
+```haskell
+-- 温度変換アダプター
+let tempAdapter = Adapter
+  { adapterTo = \(Celsius c) -> Fahrenheit (c * 9/5 + 32)
+  , adapterFrom = \(Fahrenheit f) -> Celsius ((f - 32) * 5/9)
+  }
+
+adapt tempAdapter (Celsius 0)      -- Fahrenheit 32
+adaptBack tempAdapter (Fahrenheit 32)  -- Celsius 0
+
+-- Int <-> String アダプター
+let intStringAdapter = Adapter
+  { adapterTo = show :: Int -> String
+  , adapterFrom = read
+  }
+
+adapt intStringAdapter 42      -- "42"
+adaptBack intStringAdapter "42"  -- 42
+```
+
+## 7. パターンの利点
+
+1. **既存コードの再利用**: 既存のクラスを変更せずに新しいインターフェースで使用
+2. **単一責任の原則**: インターフェース変換のロジックを分離
+3. **開放/閉鎖の原則**: 新しいアダプターを追加しても既存コードは変更不要
+4. **レガシーシステムとの統合**: 古いシステムと新しいシステムを連携
+
+## 8. Haskell での特徴
+
+Haskell での Adapter パターンの実装には以下の特徴があります：
+
+1. **型クラス**: ターゲットインターフェースを型クラスとして定義
+2. **newtype**: 異なるドメインの値を型で区別（Celsius, Fahrenheit など）
+3. **関数による変換**: 単純なデータ変換は純粋関数で直接実装
+4. **イミュータブルなデータ**: 変換後も元のデータは変更されない
+5. **合成のしやすさ**: 複数のアダプターを組み合わせ可能
+
+### 型クラスによるインターフェース
+
+```haskell
+-- 型クラスでターゲットインターフェースを定義
+class Switchable a where
+  switchTurnOn :: a -> (a, SwitchResult)
+  switchTurnOff :: a -> (a, SwitchResult)
+
+-- 任意の型をインスタンスにできる
+instance Switchable VariableLightAdapter where
+  switchTurnOn = adaptedTurnOn
+  switchTurnOff = adaptedTurnOff
+
+-- ジェネリックな関数で使用
+engageSwitch :: Switchable a => a -> (a, SwitchResult, SwitchResult)
+engageSwitch s = 
+  let (s1, onResult) = switchTurnOn s
+      (s2, offResult) = switchTurnOff s1
+  in (s2, onResult, offResult)
+```
+
+### newtype による型安全性
+
+```haskell
+-- newtype を使うことで、同じ内部表現でも異なる型として扱える
+newtype Celsius = Celsius Double
+newtype Fahrenheit = Fahrenheit Double
+
+-- コンパイル時に型チェックされる
+add :: Celsius -> Celsius -> Celsius
+add (Celsius a) (Celsius b) = Celsius (a + b)
+
+-- これはコンパイルエラーになる
+-- add (Celsius 10) (Fahrenheit 50)  -- 型不一致
+```
+
+## まとめ
+
+本章では、Adapter パターンについて学びました：
+
+1. **VariableLightAdapter**: 可変強度ライトを単純なオン/オフインターフェースに適応
+2. **データフォーマットアダプター**: 異なるデータ形式間の変換
+3. **温度・通貨アダプター**: 単位変換の実装
+4. **汎用アダプター**: 双方向変換を抽象化
+
+Adapter パターンは、既存のコードを変更せずに異なるシステムを連携させる際に非常に有効です。Haskell では型クラスと newtype を活用することで、型安全で再利用性の高いアダプターを実装できます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/haskell/part3/src/AdapterPattern.hs`
+- テストコード: `apps/haskell/part3/test/AdapterPatternSpec.hs`
+
+## 次章予告
+
+次章では、**Strategy パターン**について学びます。アルゴリズムをカプセル化し、実行時に切り替える方法を探ります。