@k2works/claude-code-booster 3.0.0 → 3.1.0

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

@@ -0,0 +1,230 @@
+# F# で学ぶ関数型デザイン
+
+## はじめに
+
+本記事シリーズは、関数型プログラミングにおける設計原則とデザインパターンを F# を使って実践的に学ぶためのガイドです。F# は .NET プラットフォーム上で動作する関数型ファースト言語であり、代数的データ型、パターンマッチング、型推論など、関数型プログラミングの本質的な機能をネイティブにサポートしています。
+
+## 記事構成
+
+### 第1部: 関数型プログラミングの基礎原則
+
+1. [不変性とデータ変換](./01-immutability-and-data-transformation.md)
+    - レコードと不変データ構造
+    - パイプライン演算子（|>）
+    - 副作用の分離
+
+2. [関数合成と高階関数](./02-function-composition.md)
+    - >> と << による関数合成
+    - カリー化と部分適用
+    - 高階関数の活用
+
+3. [多態性の実現方法](./03-polymorphism.md)
+    - 判別共用体（Discriminated Union）
+    - アクティブパターン
+    - 型拡張とインターフェース
+
+### 第2部: 仕様とテスト
+
+4. [データ検証](./04-data-validation.md)
+    - Result 型によるエラーハンドリング
+    - Computation Expression
+    - カスタムバリデータの作成
+
+5. [プロパティベーステスト](./05-property-based-testing.md)
+    - FsCheck の基本
+    - ジェネレータの作成
+    - プロパティの定義と検証
+
+6. [TDD と関数型プログラミング](./06-tdd-functional.md)
+    - xUnit / Expecto によるテスト
+    - Red-Green-Refactor サイクル
+    - テストファーストの関数設計
+
+### 第3部: 構造パターン
+
+7. [Composite パターン](./07-composite-pattern.md)
+    - 再帰的な判別共用体
+    - ツリー構造の表現
+    - fold による走査
+
+8. [Decorator パターン](./08-decorator-pattern.md)
+    - 関数合成によるデコレーション
+    - 高階関数でのラッピング
+    - 振る舞いの動的追加
+
+9. [Adapter パターン](./09-adapter-pattern.md)
+    - 関数アダプター
+    - プロトコル変換
+    - レガシーコードとの統合
+
+### 第4部: 振る舞いパターン
+
+10. [Strategy パターン](./10-strategy-pattern.md)
+    - 第一級関数としての戦略
+    - 動的な戦略切り替え
+    - 戦略の合成
+
+11. [Command パターン](./11-command-pattern.md)
+    - 不変コマンドレコード
+    - コマンドの履歴と Undo
+    - マクロコマンド
+
+12. [Visitor パターン](./12-visitor-pattern.md)
+    - パターンマッチによる訪問
+    - fold ベースのビジター
+    - 拡張可能なビジター
+
+### 第5部: 生成パターン
+
+13. [Abstract Factory パターン](./13-abstract-factory-pattern.md)
+    - 関数ファクトリー
+    - モジュールによる抽象化
+    - 依存性注入
+
+14. [Abstract Server パターン](./14-abstract-server-pattern.md)
+    - インターフェースによる抽象化
+    - 実装の差し替え
+    - テスタブルな設計
+
+### 第6部: ケーススタディ
+
+15. [ゴシップ好きなバスの運転手](./15-gossiping-bus-drivers.md)
+    - 不変状態の管理
+    - シミュレーションの実装
+    - 再帰的な処理
+
+16. [給与計算システム](./16-payroll-system.md)
+    - ドメインモデリング
+    - 多態的な計算
+    - レポート生成
+
+17. [レンタルビデオシステム](./17-video-rental-system.md)
+    - 状態遷移の管理
+    - イベントソーシング
+    - ビジネスルールの実装
+
+18. [並行処理システム](./18-concurrency-system.md)
+    - MailboxProcessor（Agent）
+    - 非同期ワークフロー
+    - 並行状態管理
+
+19. [Wa-Tor シミュレーション](./19-wator-simulation.md)
+    - セルオートマトン
+    - 不変グリッドの更新
+    - シミュレーションループ
+
+### 第7部: まとめと応用
+
+20. [パターン間の相互作用](./20-pattern-interactions.md)
+    - Composite + Decorator
+    - Command + Observer
+    - パターンの組み合わせ
+
+21. [ベストプラクティス](./21-best-practices.md)
+    - データ中心設計
+    - Computation Expression
+    - 関数デコレーター
+    - テスタブルな設計
+
+22. [OO から FP への移行](./22-oo-to-fp-migration.md)
+    - 移行戦略
+    - イベントソーシング
+    - 段階的な関数抽出
+    - 判別共用体による多態性
+
+---
+
+## 本シリーズの特徴
+
+### F# の特性を活かした実装
+
+F# は関数型プログラミングのために設計された言語であり、以下の機能をネイティブにサポートしています：
+
+- **判別共用体（Discriminated Union）**: 代数的データ型を簡潔に定義
+- **パイプライン演算子（|>）**: データ変換の流れを自然に記述
+- **パターンマッチング**: 網羅性チェック付きの強力なパターンマッチ
+- **型推論**: 明示的な型注釈を最小限に
+- **Computation Expression**: モナド的な計算を DSL として定義
+
+### 実践重視
+
+すべてのパターンは xUnit による実際に動作するテストコードを含みます。理論だけでなく、実装を通じて理解を深めることを重視しています。
+
+### 段階的な学習
+
+基礎から応用へと段階的に内容が進行します。各章は独立して読むこともできますが、順番に読むことでより深い理解が得られます。
+
+---
+
+## 対象読者
+
+- 関数型プログラミングに興味がある F# 開発者
+- F# を学習中の開発者
+- オブジェクト指向デザインパターンの知識があり、関数型での表現を学びたい開発者
+- Clojure / Scala 版と比較して学習したい開発者
+- .NET 環境で関数型アプローチを導入したい開発者
+
+---
+
+## 前提知識
+
+- プログラミングの基礎知識
+- F# の基本的な文法（let バインディング、関数定義、パターンマッチングなど）
+- デザインパターンの基本概念（推奨）
+
+---
+
+## 開発環境
+
+本シリーズのコードは以下の環境で動作確認しています：
+
+- .NET 8.0
+- F# 8.0
+- xUnit 2.x
+- FsCheck（プロパティベーステスト用）
+- Nix による環境管理
+
+### 環境構築
+
+```bash
+# Nix を使用した開発環境の起動
+nix develop .#fsharp
+
+# プロジェクトの作成（Part 1 の例）
+cd apps/fsharp/part1
+dotnet new sln -n FunctionalDesignPart1
+dotnet new classlib -lang F# -n FunctionalDesign -o src
+dotnet new xunit -lang F# -n FunctionalDesign.Tests -o tests
+dotnet sln add src/FunctionalDesign.fsproj tests/FunctionalDesign.Tests.fsproj
+dotnet add tests/FunctionalDesign.Tests.fsproj reference src/FunctionalDesign.fsproj
+
+# テストの実行
+dotnet test
+
+# REPL の起動
+dotnet fsi
+```
+
+---
+
+## Clojure / Scala との比較
+
+| 概念 | Clojure | Scala | F# |
+|-----|---------|-------|-----|
+| 不変データ | デフォルト | `val`, `case class` | デフォルト |
+| ADT | プロトコル + レコード | `sealed trait` | 判別共用体 |
+| パイプライン | `->`, `->>` | メソッドチェーン | `|>`, `>>` |
+| パターンマッチ | `case`, `cond` | `match` | `match` |
+| 型システム | 動的 | 静的（強い） | 静的（強い推論） |
+| 並行処理 | Agent, core.async | Future, Actor | MailboxProcessor, Async |
+
+---
+
+## 参考書籍
+
+本シリーズは以下の書籍の内容を参考にしています：
+
+- 「Functional Design: Principles, Patterns, and Practices」Robert C. Martin
+- 「Domain Modeling Made Functional」Scott Wlaschin
+- 「F# for Fun and Profit」Scott Wlaschin（オンライン）
+- 「Real-World Functional Programming」Tomas Petricek, Jon Skeet

package/lib/assets/docs/article/functional-desgin-ppp/haskell/01-immutability-and-data-transformation.md

@@ -0,0 +1,298 @@
+# 第1章: 不変性とデータ変換
+
+## はじめに
+
+関数型プログラミングの最も重要な概念の一つが**不変性（Immutability）**です。Haskell はデフォルトで不変であり、すべての値は一度作成されると変更できません。これにより、プログラムの予測可能性が向上し、並行処理での問題を防ぎます。
+
+本章では、Haskell における不変データ構造の基本から、データ変換パイプライン、副作用の分離まで、実践的な例を通じて学びます。
+
+## 1. 不変データ構造の基本
+
+### レコード型による不変データ
+
+Haskell のレコード構文を使ってデータ型を定義します：
+
+```haskell
+-- | Person レコード（不変）
+data Person = Person
+    { personName :: String
+    , personAge  :: Int
+    } deriving (Show, Eq)
+
+-- | 年齢を更新する関数（新しい Person を返す）
+updateAge :: Person -> Int -> Person
+updateAge person newAge = person { personAge = newAge }
+
+-- 使用例
+let original = Person "田中" 30
+let updated = updateAge original 31
+
+original   -- => Person {personName = "田中", personAge = 30}  ← 元は変わらない
+updated    -- => Person {personName = "田中", personAge = 31}  ← 新しい値
+```
+
+### 不変性の利点
+
+1. **参照透過性**: 同じ入力に対して常に同じ出力
+2. **スレッドセーフ**: 複数スレッドから安全にアクセス可能
+3. **推論の容易さ**: 値が変わらないため動作を追跡しやすい
+4. **遅延評価との相性**: 必要になるまで計算を遅延できる
+
+## 2. 構造共有（Structural Sharing）
+
+Haskell のリストや木構造は構造共有により効率的にメモリを使用します：
+
+```haskell
+-- | チームメンバー
+data Role = Developer | Designer | Manager
+    deriving (Show, Eq)
+
+data Member = Member
+    { memberName :: String
+    , memberRole :: Role
+    } deriving (Show, Eq)
+
+-- | チーム
+data Team = Team
+    { teamName    :: String
+    , teamMembers :: [Member]
+    } deriving (Show, Eq)
+
+-- | メンバーを追加（既存リストは共有される）
+addMember :: Team -> Member -> Team
+addMember team newMember = team { teamMembers = teamMembers team ++ [newMember] }
+```
+
+```plantuml
+@startuml
+title 構造共有（Structural Sharing）
+
+object "team" as team {
+  teamName = "開発チーム"
+}
+
+object "newTeam" as newTeam {
+  teamName = "開発チーム"
+}
+
+object "List[田中, 鈴木, 佐藤]" as oldList
+object "山田" as newMember
+
+team --> oldList : teamMembers
+newTeam --> oldList : 共有
+newTeam --> newMember : 追加のみ
+
+note bottom of oldList
+  既存データは共有され
+  コピーされない
+end note
+@enduml
+```
+
+## 3. データ変換パイプライン
+
+### パイプライン演算子と関数適用
+
+Haskell では `$` と `&`（Data.Function から）を使ってパイプラインを構築します：
+
+```haskell
+import Data.Function ((&))
+
+-- | 注文アイテム
+data Item = Item
+    { itemName     :: String
+    , itemPrice    :: Int
+    , itemQuantity :: Int
+    } deriving (Show, Eq)
+
+-- | 会員種別
+data Membership = Gold | Silver | Bronze | Regular
+    deriving (Show, Eq)
+
+-- | 顧客
+data Customer = Customer
+    { customerName       :: String
+    , customerMembership :: Membership
+    } deriving (Show, Eq)
+
+-- | 注文
+data Order = Order
+    { orderItems    :: [Item]
+    , orderCustomer :: Customer
+    } deriving (Show, Eq)
+
+-- | アイテムの小計を計算
+calculateSubtotal :: Item -> Int
+calculateSubtotal item = itemPrice item * itemQuantity item
+
+-- | 会員割引率を取得
+membershipDiscount :: Membership -> Double
+membershipDiscount Gold   = 0.1
+membershipDiscount Silver = 0.05
+membershipDiscount Bronze = 0.02
+membershipDiscount Regular = 0.0
+
+-- | 注文合計を計算
+calculateTotal :: Order -> Int
+calculateTotal order = sum $ map calculateSubtotal (orderItems order)
+
+-- | 割引を適用
+applyDiscount :: Order -> Int -> Double
+applyDiscount order total =
+    let discountRate = membershipDiscount (customerMembership (orderCustomer order))
+    in fromIntegral total * (1 - discountRate)
+
+-- | 注文処理パイプライン
+processOrder :: Order -> Double
+processOrder order =
+    let total = calculateTotal order
+    in applyDiscount order total
+
+-- または & を使った記法
+processOrderPipe :: Order -> Double
+processOrderPipe order =
+    order
+    & calculateTotal
+    & applyDiscount order
+```
+
+## 4. 副作用の分離
+
+Haskell では副作用は IO モナドで明示的に扱います：
+
+```haskell
+-- | 請求書データ
+data Invoice = Invoice
+    { invoiceSubtotal :: Int
+    , invoiceTax      :: Double
+    , invoiceTotal    :: Double
+    } deriving (Show, Eq)
+
+-- | 請求書を計算（純粋関数）
+calculateInvoice :: [Item] -> Double -> Invoice
+calculateInvoice items taxRate =
+    let subtotal = sum $ map calculateSubtotal items
+        tax = fromIntegral subtotal * taxRate
+        total = fromIntegral subtotal + tax
+    in Invoice subtotal tax total
+
+-- | 請求書を保存（IO を含む副作用）
+saveInvoice :: Invoice -> IO ()
+saveInvoice invoice = do
+    putStrLn $ "Saving invoice: " ++ show invoice
+    -- 実際のDB保存処理
+
+-- | 通知を送信（IO を含む副作用）
+sendNotification :: Invoice -> String -> IO ()
+sendNotification invoice email = do
+    putStrLn $ "Sending to: " ++ email
+    -- 実際のメール送信処理
+
+-- | 処理全体のオーケストレーション
+processAndSaveInvoice :: [Item] -> Double -> String -> IO ()
+processAndSaveInvoice items taxRate email = do
+    let invoice = calculateInvoice items taxRate  -- 純粋な計算
+    saveInvoice invoice                            -- 副作用
+    sendNotification invoice email                 -- 副作用
+```
+
+## 5. 永続的データ構造：Undo/Redo の実装
+
+不変データを活用した履歴管理：
+
+```haskell
+-- | 履歴を保持するデータ構造
+data History a = History
+    { historyCurrent :: Maybe a
+    , historyPast    :: [a]
+    , historyFuture  :: [a]
+    } deriving (Show, Eq)
+
+-- | 空の履歴を作成
+createHistory :: History a
+createHistory = History Nothing [] []
+
+-- | 新しい状態をプッシュ
+pushState :: History a -> a -> History a
+pushState history newState =
+    History
+        { historyCurrent = Just newState
+        , historyPast = case historyCurrent history of
+            Nothing -> historyPast history
+            Just current -> current : historyPast history
+        , historyFuture = []  -- 新状態で未来はクリア
+        }
+
+-- | Undo 操作
+undo :: History a -> History a
+undo history = case historyPast history of
+    [] -> history  -- 戻る履歴がない
+    (prev:rest) -> History
+        { historyCurrent = Just prev
+        , historyPast = rest
+        , historyFuture = case historyCurrent history of
+            Nothing -> historyFuture history
+            Just current -> current : historyFuture history
+        }
+
+-- | Redo 操作
+redo :: History a -> History a
+redo history = case historyFuture history of
+    [] -> history  -- 進む履歴がない
+    (next:rest) -> History
+        { historyCurrent = Just next
+        , historyPast = case historyCurrent history of
+            Nothing -> historyPast history
+            Just current -> current : historyPast history
+        , historyFuture = rest
+        }
+
+-- | 現在の状態を取得
+currentState :: History a -> Maybe a
+currentState = historyCurrent
+
+-- | Undo 可能か
+canUndo :: History a -> Bool
+canUndo = not . null . historyPast
+
+-- | Redo 可能か
+canRedo :: History a -> Bool
+canRedo = not . null . historyFuture
+```
+
+### 使用例
+
+```haskell
+-- 履歴の操作
+let h1 = createHistory :: History Int
+let h2 = pushState h1 1
+let h3 = pushState h2 2
+let h4 = pushState h3 3
+
+currentState h4  -- => Just 3
+canUndo h4       -- => True
+
+let h5 = undo h4
+currentState h5  -- => Just 2
+canRedo h5       -- => True
+
+let h6 = redo h5
+currentState h6  -- => Just 3
+```
+
+## 6. まとめ
+
+Haskell における不変性の特徴：
+
+| 概念 | Haskell での実現 |
+|-----|-----------------|
+| 不変データ | デフォルトで不変（let で束縛） |
+| レコード更新 | `{ record \| field = newValue }` 構文 |
+| 構造共有 | 自動的に最適化される |
+| パイプライン | `$`、`&`、関数合成 (.) |
+| 副作用分離 | IO モナドで明示的に |
+
+### 次のステップ
+
+- 第2章では関数合成と高階関数を学びます
+- 第3章では型クラスによる多態性を探ります