@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/functional-desgin-ppp/haskell/22-oo-to-fp-migration.md

@@ -1,478 +0,0 @@
----
-type: Article
-title: "第22章 オブジェクト指向から関数型への移行"
-description: "この章では、一般的なオブジェクト指向パターンを関数型の同等物に移行する方法を学びます。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第22章 オブジェクト指向から関数型への移行
-
-## 概要
-
-この章では、一般的なオブジェクト指向パターンを関数型の同等物に移行する方法を学びます。継承からコンポジション、ミュータブルステートからイミュータブル更新、デザインパターンの関数型表現まで、実践的な変換パターンを示します。
-
-## 学習目標
-
-- クラス階層から代数的データ型への変換
-- 継承からコンポジションへの移行
-- ミュータブルステートのイミュータブル化
-- OO パターンの関数型等価物
-
-## クラスからデータ型への移行
-
-### OO: 継承階層 → FP: 直和型
-
-```haskell
--- OO のクラス階層の代わりに直和型を使用
-data Animal
-  = Dog { dogName :: String, dogBreed :: String }
-  | Cat { catName :: String, catColor :: String }
-  | Bird { birdName :: String, birdCanFly :: Bool }
-  deriving (Show, Eq)
-
--- ポリモーフィズムはパターンマッチで実現
-makeSound :: Animal -> String
-makeSound (Dog name _) = name ++ " says: Woof!"
-makeSound (Cat name _) = name ++ " says: Meow!"
-makeSound (Bird name _) = name ++ " says: Tweet!"
-
-move :: Animal -> String
-move (Dog name _) = name ++ " runs on four legs"
-move (Cat name _) = name ++ " prowls silently"
-move (Bird name canFly)
-  | canFly = name ++ " flies through the air"
-  | otherwise = name ++ " hops on the ground"
-
-describeAnimal :: Animal -> String
-describeAnimal animal = makeSound animal ++ " and " ++ move animal
-```
-
-### OO: インターフェース → FP: 型クラス
-
-```haskell
--- OO のインターフェースの代わりに型クラスを使用
-class Shape a where
-  area :: a -> Double
-  perimeter :: a -> Double
-
--- 各形状の実装
-data Circle = Circle { circleRadius :: Double }
-  deriving (Show, Eq)
-
-instance Shape Circle where
-  area (Circle r) = pi * r * r
-  perimeter (Circle r) = 2 * pi * r
-
-data Rectangle = Rectangle { rectWidth :: Double, rectHeight :: Double }
-  deriving (Show, Eq)
-
-instance Shape Rectangle where
-  area (Rectangle w h) = w * h
-  perimeter (Rectangle w h) = 2 * (w + h)
-```
-
-## 継承からコンポジションへ
-
-### OO: 継承階層 → FP: コンポジション
-
-```haskell
--- コンポーネント
-data Engine
-  = NoEngine
-  | GasEngine { horsepower :: Int }
-  | ElectricEngine { batteryKwh :: Int }
-  deriving (Show, Eq)
-
-data Wheels = Wheels { wheelCount :: Int, wheelSize :: Int }
-  deriving (Show, Eq)
-
--- コンポジションによる Vehicle
-data Vehicle = Vehicle
-  { vehicleName :: String
-  , vehicleEngine :: Engine
-  , vehicleWheels :: Wheels
-  } deriving (Show, Eq)
-
--- ファクトリー関数
-car :: Vehicle
-car = Vehicle "Car" (GasEngine 200) (Wheels 4 17)
-
-motorcycle :: Vehicle
-motorcycle = Vehicle "Motorcycle" (GasEngine 80) (Wheels 2 18)
-
-bicycle :: Vehicle
-bicycle = Vehicle "Bicycle" NoEngine (Wheels 2 26)
-
--- 振る舞いは関数で定義
-describeVehicle :: Vehicle -> String
-describeVehicle v = vehicleName v ++ " with " ++ engineDesc ++ " and " ++ wheelsDesc
-  where
-    engineDesc = case vehicleEngine v of
-      NoEngine -> "no engine"
-      GasEngine hp -> show hp ++ "hp gas engine"
-      ElectricEngine kw -> show kw ++ "kWh electric engine"
-    wheelsDesc = show (wheelCount (vehicleWheels v)) ++ " wheels"
-```
-
-## ミュータブルステートからイミュータブル更新へ
-
-### OO: ミュータブルオブジェクト → FP: イミュータブルレコード
-
-```haskell
--- イミュータブルな銀行口座
-data BankAccount = BankAccount
-  { accountId :: String
-  , accountBalance :: Double
-  , accountOwner :: String
-  } deriving (Show, Eq)
-
--- 作成
-makeAccount :: String -> String -> Double -> BankAccount
-makeAccount aid owner initial = BankAccount aid initial owner
-
--- 預金（新しい口座を返す）
-deposit :: Double -> BankAccount -> BankAccount
-deposit amount account
-  | amount > 0 = account { accountBalance = accountBalance account + amount }
-  | otherwise = account
-
--- 引き出し（失敗する可能性をMaybeで表現）
-withdraw :: Double -> BankAccount -> Maybe BankAccount
-withdraw amount account
-  | amount > 0 && accountBalance account >= amount =
-      Just account { accountBalance = accountBalance account - amount }
-  | otherwise = Nothing
-
--- 送金
-transfer :: Double -> BankAccount -> BankAccount -> Maybe (BankAccount, BankAccount)
-transfer amount from to = do
-  from' <- withdraw amount from
-  let to' = deposit amount to
-  return (from', to')
-
--- 使用例
-let alice = makeAccount "A001" "Alice" 1000
-    bob = makeAccount "B001" "Bob" 500
-case transfer 200 alice bob of
-  Just (alice', bob') -> do
-    putStrLn $ "Alice: " ++ show (accountBalance alice')  -- 800
-    putStrLn $ "Bob: " ++ show (accountBalance bob')      -- 700
-  Nothing -> putStrLn "Transfer failed"
-```
-
-## Strategy パターンの移行
-
-### OO: Strategy インターフェース → FP: 関数
-
-```haskell
--- Strategy を関数として表現
-type PaymentMethod = Double -> String -> Either String String
-
--- 具体的な Strategy
-creditCard :: String -> PaymentMethod
-creditCard cardNumber amount merchant =
-  Right $ "Paid $" ++ show amount ++ " to " ++ merchant ++ 
-          " via credit card " ++ take 4 cardNumber ++ "****"
-
-paypal :: String -> PaymentMethod
-paypal email amount merchant =
-  Right $ "Paid $" ++ show amount ++ " to " ++ merchant ++ 
-          " via PayPal (" ++ email ++ ")"
-
-bitcoin :: String -> PaymentMethod
-bitcoin wallet amount merchant =
-  Right $ "Paid $" ++ show amount ++ " to " ++ merchant ++ 
-          " via Bitcoin wallet " ++ take 8 wallet ++ "..."
-
--- Strategy を使用
-processPayment :: PaymentMethod -> Double -> String -> Either String String
-processPayment method amount merchant = method amount merchant
-
--- 使用例
-let strategy = creditCard "1234567890123456"
-processPayment strategy 100.0 "Amazon"
--- Right "Paid $100.0 to Amazon via credit card 1234****"
-```
-
-## Observer パターンの移行
-
-### OO: Observer インターフェース → FP: 関数リスト
-
-```haskell
--- イベント
-data Event
-  = UserCreated String
-  | UserDeleted String
-  | OrderPlaced String Double
-  | OrderCancelled String
-  deriving (Show, Eq)
-
--- サブスクリプション（イベントを受け取る関数）
-type Subscription = Event -> String
-
--- サブスクライブ
-subscribe :: String -> Subscription
-subscribe subscriberName event = case event of
-  UserCreated user -> subscriberName ++ " notified: User " ++ user ++ " created"
-  OrderPlaced orderId amount -> 
-    subscriberName ++ " notified: Order " ++ orderId ++ " placed for $" ++ show amount
-  _ -> subscriberName ++ " notified of event"
-
--- パブリッシュ
-publish :: [Subscription] -> Event -> [String]
-publish subscribers event = map ($ event) subscribers
-
--- イベントログ（純粋関数）
-type EventLog = [Event]
-
-logEvent :: Event -> EventLog -> EventLog
-logEvent event log' = event : log'
-
--- 使用例
-let emailSub = subscribe "EmailService"
-    smsSub = subscribe "SMSService"
-    notifications = publish [emailSub, smsSub] (OrderPlaced "ORD001" 99.99)
--- ["EmailService notified: Order ORD001 placed for $99.99",
---  "SMSService notified: Order ORD001 placed for $99.99"]
-```
-
-## Factory パターンの移行
-
-### OO: Factory クラス → FP: スマートコンストラクタ
-
-```haskell
--- ドキュメント型
-data Document
-  = PDFDocument String
-  | WordDocument String
-  | HTMLDocument String
-  deriving (Show, Eq)
-
--- スマートコンストラクタ
-createPDF :: String -> Document
-createPDF = PDFDocument
-
-createWord :: String -> Document
-createWord = WordDocument
-
-createHTML :: String -> Document
-createHTML = HTMLDocument
-
--- レンダリング
-renderDocument :: Document -> String
-renderDocument (PDFDocument content) = "<PDF>" ++ content ++ "</PDF>"
-renderDocument (WordDocument content) = "<WORD>" ++ content ++ "</WORD>"
-renderDocument (HTMLDocument content) = "<html><body>" ++ content ++ "</body></html>"
-```
-
-## Singleton の移行
-
-### OO: Singleton クラス → FP: モジュールレベル値
-
-```haskell
--- 設定型
-data Config = Config
-  { configDbHost :: String
-  , configDbPort :: Int
-  , configLogLevel :: String
-  } deriving (Show, Eq)
-
--- モジュールレベルの値（Singleton の代わり）
-defaultConfig :: Config
-defaultConfig = Config "localhost" 5432 "INFO"
-
-testConfig :: Config
-testConfig = Config "localhost" 5433 "DEBUG"
-
-productionConfig :: Config
-productionConfig = Config "prod.db.example.com" 5432 "WARN"
-
--- 使用時に明示的に渡す
-runApp :: Config -> IO ()
-runApp config = do
-  putStrLn $ "Connecting to " ++ configDbHost config
-  -- ...
-```
-
-## Null Object の移行
-
-### OO: Null Object パターン → FP: Maybe
-
-```haskell
--- ユーザー検索（Maybe を返す）
-findUser :: String -> Maybe SimpleUser
-findUser userId = Map.lookup userId userDatabase
-
--- 安全なナビゲーション
-getUserName :: String -> Maybe String
-getUserName userId = simpleUserName <$> findUser userId
-
--- デフォルト値付き
-getUserNameOrDefault :: String -> String -> String
-getUserNameOrDefault userId defaultName =
-  maybe defaultName simpleUserName (findUser userId)
-
--- 使用例
-getUserName "1"                      -- Just "Alice"
-getUserName "999"                    -- Nothing
-getUserNameOrDefault "999" "Unknown" -- "Unknown"
-```
-
-## Template Method の移行
-
-### OO: Template Method → FP: 高階関数
-
-```haskell
--- データプロセッサ（関数として表現）
-type DataProcessor = String -> String
-
--- 具体的なプロセッサ
-csvProcessor :: DataProcessor
-csvProcessor input = "CSV[" ++ input ++ "]"
-
-jsonProcessor :: DataProcessor
-jsonProcessor input = "{\"data\": \"" ++ input ++ "\"}"
-
-xmlProcessor :: DataProcessor
-xmlProcessor input = "<data>" ++ input ++ "</data>"
-
--- テンプレートメソッドの等価物（高階関数）
-processData :: DataProcessor -> String -> String
-processData processor input =
-  let validated = "validated:" ++ input
-      transformed = processor validated
-      output = "output:" ++ transformed
-  in output
-
--- 使用例
-processData csvProcessor "test"   -- "output:CSV[validated:test]"
-processData jsonProcessor "test"  -- "output:{\"data\": \"validated:test\"}"
-```
-
-## Chain of Responsibility の移行
-
-### OO: Handler チェーン → FP: 関数合成
-
-```haskell
--- リクエスト
-data Request = Request
-  { reqPath :: String
-  , reqMethod :: String
-  , reqHeaders :: Map String String
-  , reqBody :: String
-  } deriving (Show, Eq)
-
--- ハンドラー（関数として表現）
-type Handler = Request -> Either String Request
-
--- 具体的なハンドラー
-authHandler :: Handler
-authHandler req =
-  case Map.lookup "Authorization" (reqHeaders req) of
-    Nothing -> Left "Unauthorized: No auth header"
-    Just _ -> Right req
-
-validationHandler :: Handler
-validationHandler req
-  | null (reqBody req) && reqMethod req == "POST" = Left "Bad Request: Empty body"
-  | otherwise = Right req
-
-loggingHandler :: Handler
-loggingHandler req = Right req
-
--- ハンドラーの連結
-chainHandlers :: [Handler] -> Handler
-chainHandlers [] req = Right req
-chainHandlers (h:hs) req = case h req of
-  Left err -> Left err
-  Right req' -> chainHandlers hs req'
-
--- 使用例
-let handlers = chainHandlers [authHandler, loggingHandler, validationHandler]
-    request = Request "/api/users" "POST" 
-              (Map.fromList [("Authorization", "Bearer token")]) 
-              "{\"name\":\"test\"}"
-handlers request  -- Right Request {...}
-```
-
-## テスト
-
-```haskell
-spec :: Spec
-spec = do
-  describe "Class to Data Type Migration" $ do
-    it "animals make sounds" $ do
-      let dog = Dog "Rex" "German Shepherd"
-      makeSound dog `shouldBe` "Rex says: Woof!"
-
-  describe "Immutable Updates" $ do
-    it "deposit creates new account" $ do
-      let account = makeAccount "A001" "Alice" 1000
-          account' = deposit 500 account
-      getBalance account' `shouldBe` 1500
-      getBalance account `shouldBe` 1000  -- 元のデータは変更されない
-
-  describe "Strategy Migration" $ do
-    it "uses payment strategy" $ do
-      let strategy = creditCard "1234567890123456"
-      case processPayment strategy 100.0 "Store" of
-        Right msg -> "credit card" `isInfixOf` msg `shouldBe` True
-        Left _ -> expectationFailure "Should succeed"
-
-  describe "Chain of Responsibility" $ do
-    it "chains handlers" $ do
-      let handlers = chainHandlers [authHandler, validationHandler]
-          validReq = Request "/api" "POST" 
-                     (Map.fromList [("Authorization", "token")]) 
-                     "body"
-      case handlers validReq of
-        Right _ -> return ()
-        Left _ -> expectationFailure "Should pass"
-```
-
-## 移行のガイドライン
-
-### 1. 継承よりコンポジション
-
-```haskell
--- 悪い例（継承の模倣）
--- 良い例（コンポジション）
-data Component = Component { ... }
-data Entity = Entity { entityComponents :: [Component] }
-```
-
-### 2. ミュータブルステートの排除
-
-```haskell
--- 悪い例：IORef を多用
--- 良い例：純粋関数で状態を変換
-update :: State -> Action -> State
-```
-
-### 3. 例外より戻り値
-
-```haskell
--- 悪い例：例外をスロー
--- 良い例：Maybe/Either で失敗を表現
-findUser :: String -> Maybe User
-processOrder :: Order -> Either OrderError Receipt
-```
-
-### 4. インターフェースより関数
-
-```haskell
--- 悪い例：型クラスの乱用
--- 良い例：関数を直接渡す
-type Strategy a = a -> a
-applyStrategy :: Strategy a -> a -> a
-```
-
-## まとめ
-
-- 継承階層は直和型で表現
-- ポリモーフィズムはパターンマッチまたは型クラス
-- ミュータブルステートはイミュータブルレコードの変換
-- OO パターンの多くは関数と高階関数で簡潔に表現可能
-- 型システムにより、より安全な設計が可能

package/lib/assets/docs/article/functional-desgin-ppp/haskell/index.md

@@ -1,174 +0,0 @@
-# Haskell による関数型デザイン
-
-## 概要
-
-本セクションでは、Robert C. Martin の「Functional Design: Principles, Patterns, and Practices」で紹介されている関数型プログラミングの原則とパターンを Haskell で実装します。
-
-Haskell は純粋関数型言語として、関数型プログラミングの概念を最も直接的に表現できる言語の一つです。遅延評価、強い型システム、型クラスなどの特徴により、抽象度の高いコードを安全に記述できます。
-
-## 構成
-
-### 第1部：基礎原則（Chapters 1-3）
-
-1. [不変性とデータ変換](01-immutability-and-data-transformation.md) - レコード、構造共有、パイプライン
-2. [関数合成と高階関数](02-function-composition.md) - (.)、(>>>)、カリー化、部分適用
-3. [多態性とディスパッチ](03-polymorphism.md) - ADT、型クラス、パターンマッチ
-
-### 第2部：仕様とテスト（Chapters 4-6）
-
-4. [データバリデーション](04-data-validation.md) - カスタムバリデータ、Applicative スタイル
-5. [プロパティベーステスト](05-property-based-testing.md) - QuickCheck
-6. [TDD と関数型](06-tdd-functional.md) - HSpec によるテスト駆動開発
-
-### 第3部：構造パターン（Chapters 7-9）
-
-7. [Composite パターン](07-composite-pattern.md) - 再帰的データ構造
-8. [Decorator パターン](08-decorator-pattern.md) - 関数ラッパー
-9. [Adapter パターン](09-adapter-pattern.md) - 型変換、newtypes
-
-### 第4部：振る舞いパターン（Chapters 10-14）
-
-10. [Strategy パターン](10-strategy-pattern.md) - 高階関数による戦略切り替え
-11. [Command パターン](11-command-pattern.md) - データとしてのコマンド
-12. [Visitor パターン](12-visitor-pattern.md) - Foldable/Traversable
-13. [Abstract Factory パターン](13-abstract-factory-pattern.md) - 型クラスによる抽象化
-14. [Abstract Server パターン](14-abstract-server-pattern.md) - モジュラー設計
-
-### 第5部：実践アプリケーション（Chapters 15-19）
-
-15. [ゴシップ好きなバスの運転手](15-gossiping-bus-drivers.md) - シミュレーション
-16. [給与計算システム](16-payroll-system.md) - ビジネスロジック
-17. [レンタルビデオシステム](17-video-rental-system.md) - ドメインモデリング
-18. [並行処理システム](18-concurrency-system.md) - STM、async
-19. [Wa-Tor シミュレーション](19-wator-simulation.md) - セルオートマトン
-
-### 第6部：ベストプラクティス（Chapters 20-22）
-
-20. [パターン間の相互作用](20-pattern-interactions.md) - パターンの組み合わせ
-21. [ベストプラクティス](21-best-practices.md) - イディオム、スタイル
-22. [OO から FP への移行](22-oo-to-fp-migration.md) - リファクタリング戦略
-
-## Haskell の特徴
-
-### 純粋性と参照透過性
-
-```haskell
--- 純粋関数：同じ入力には常に同じ出力
-calculateArea :: Double -> Double -> Double
-calculateArea width height = width * height
-
--- IO はモナドで明示的に扱う
-main :: IO ()
-main = do
-    putStrLn "Enter width:"
-    w <- readLn
-    putStrLn "Enter height:"
-    h <- readLn
-    print (calculateArea w h)
-```
-
-### 代数的データ型（ADT）
-
-```haskell
--- 直和型（Sum Type）
-data Shape
-    = Circle Double
-    | Rectangle Double Double
-    | Triangle Double Double
-    deriving (Show, Eq)
-
--- パターンマッチで網羅的に処理
-area :: Shape -> Double
-area (Circle r) = pi * r * r
-area (Rectangle w h) = w * h
-area (Triangle b h) = b * h / 2
-```
-
-### 型クラス
-
-```haskell
--- アドホック多相性を実現
-class Drawable a where
-    draw :: a -> String
-    boundingBox :: a -> (Double, Double, Double, Double)
-
-instance Drawable Shape where
-    draw (Circle r) = "Circle with radius " ++ show r
-    draw (Rectangle w h) = "Rectangle " ++ show w ++ "x" ++ show h
-    draw (Triangle b h) = "Triangle with base " ++ show b
-    
-    boundingBox (Circle r) = (-r, -r, r, r)
-    boundingBox (Rectangle w h) = (0, 0, w, h)
-    boundingBox (Triangle b h) = (0, 0, b, h)
-```
-
-### 関数合成
-
-```haskell
--- (.) で右から左へ合成
-process :: String -> Int
-process = length . filter isDigit . map toLower
-
--- (>>>) で左から右へ合成（Control.Arrow）
-processArrow :: String -> Int
-processArrow = map toLower >>> filter isDigit >>> length
-
--- パイプライン演算子（& from Data.Function）
-result = "Hello123"
-       & map toLower
-       & filter isDigit
-       & length
-```
-
-## 開発環境
-
-### 必要なツール
-
-- GHC 9.4 以上
-- Cabal または Stack
-- HLS（Haskell Language Server）
-
-### Nix を使用する場合
-
-```bash
-nix develop .#haskell
-```
-
-### プロジェクト構造
-
-```
-apps/haskell/
-├── part1/                    # 第1部：基礎原則
-│   ├── functional-design-part1.cabal
-│   ├── src/
-│   │   ├── Immutability.hs
-│   │   ├── FunctionComposition.hs
-│   │   └── Polymorphism.hs
-│   └── test/
-│       ├── Spec.hs
-│       ├── ImmutabilitySpec.hs
-│       ├── FunctionCompositionSpec.hs
-│       └── PolymorphismSpec.hs
-├── part2/                    # 第2部：仕様とテスト
-├── part3/                    # 第3部：構造パターン
-├── part4/                    # 第4部：振る舞いパターン
-├── part5/                    # 第5部：実践
-├── part6/                    # 第6部：並行処理
-└── part7/                    # 第7部：ベストプラクティス
-```
-
-### ビルドとテスト
-
-```bash
-cd apps/haskell/part1
-cabal build
-cabal test --test-show-details=streaming
-```
-
-## 参考リソース
-
-- [Haskell公式サイト](https://www.haskell.org/)
-- [Learn You a Haskell](http://learnyouahaskell.com/)
-- [Real World Haskell](http://book.realworldhaskell.org/)
-- [Typeclassopedia](https://wiki.haskell.org/Typeclassopedia)
-- [Haskell Design Patterns](https://www.fpcomplete.com/haskell/tutorial/all-about-strictness/)