@k2works/claude-code-booster 6.1.0 → 6.3.0

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

@@ -1,274 +0,0 @@
-# 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

@@ -1,307 +0,0 @@
----
-type: Article
-title: "第1章: 不変性とデータ変換"
-description: "関数型プログラミングの最も重要な概念の一つが不変性（Immutability）です。"
-tags: [article, functional-desgin-ppp, haskell]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第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章では型クラスによる多態性を探ります