@k2works/claude-code-booster 6.2.0 → 6.3.1

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

@@ -1,328 +0,0 @@
----
-type: Article
-title: "第8章: Decorator パターン"
-description: "Decorator パターンは、既存のオブジェクトに新しい機能を動的に追加するパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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

@@ -1,391 +0,0 @@
----
-type: Article
-title: "第9章: Adapter パターン"
-description: "Adapter パターンは、既存のクラスのインターフェースを、クライアントが期待する別のインターフェースに変換するパターンです。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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 パターン**について学びます。アルゴリズムをカプセル化し、実行時に切り替える方法を探ります。