@k2works/claude-code-booster 6.2.0 → 6.3.0

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/15-gossiping-bus-drivers.md

@@ -1,364 +0,0 @@
----
-type: Article
-title: "第15章: ゴシップ好きなバスの運転手"
-description: "本章では、「ゴシップ好きなバスの運転手」という問題を通じて、関数型プログラミングの実践的なアプローチを学びます。"
-tags: [article, functional-desgin-ppp, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-27T04:43:33Z }
----
-
-# 第15章: ゴシップ好きなバスの運転手
-
-## はじめに
-
-本章では、「ゴシップ好きなバスの運転手」という問題を通じて、関数型プログラミングの実践的なアプローチを学びます。この問題は、バス運転手が停留所で出会ったときに噂を共有するというシミュレーションです。
-
-この問題を通じて以下の概念を学びます：
-
-- 循環シーケンスによるルート表現
-- 集合演算による状態の伝播
-- データ変換パイプラインの設計
-
-## 1. 問題の説明
-
-複数のバス運転手がそれぞれのルートを巡回しています。各運転手は最初に1つ以上の噂を知っています。同じ停留所に複数の運転手がいると、彼らは知っている噂をすべて共有します。
-
-**ゴール**: 全ての運転手が全ての噂を知るまでに何分かかるか？
-
-```plantuml
-@startuml
-title ゴシップ好きなバスの運転手
-
-actor "Driver 1" as d1
-actor "Driver 2" as d2
-actor "Driver 3" as d3
-
-rectangle "Stop 1" as s1
-rectangle "Stop 2" as s2
-rectangle "Stop 3" as s3
-
-d1 --> s1 : 噂A
-d2 --> s1 : 噂B
-d3 --> s2 : 噂C
-
-note bottom of s1
-  同じ停留所にいる運転手は
-  噂を共有する
-  D1, D2 => {噂A, 噂B}
-end note
-@enduml
-```
-
-## 2. データモデル
-
-### ドライバーの表現
-
-```fsharp
-/// 噂の型（文字列の集合）
-type Rumors = Set<string>
-
-/// ドライバーの型
-type Driver =
-    { Name: string
-      Route: int list       // 元のルート（循環用）
-      Position: int         // 現在のルート位置
-      Rumors: Rumors }
-```
-
-ポイント:
-
-
-- `Route` はリストで保持し、`Position` でインデックスを管理
-- 噂は `Set<string>` として管理（集合演算が容易）
-
-### ドライバー操作
-
-```fsharp
-module Driver =
-    /// ドライバーを作成
-    let create (name: string) (route: int list) (rumors: Rumors) : Driver =
-        { Name = name
-          Route = route
-          Position = 0
-          Rumors = rumors }
-
-    /// 現在の停留所を取得
-    let currentStop (driver: Driver) : int =
-        driver.Route.[driver.Position % driver.Route.Length]
-
-    /// 次の停留所に移動
-    let move (driver: Driver) : Driver =
-        { driver with Position = driver.Position + 1 }
-
-    /// 噂を追加
-    let addRumors (newRumors: Rumors) (driver: Driver) : Driver =
-        { driver with Rumors = Set.union driver.Rumors newRumors }
-```
-
-### 循環ルートの実現
-
-```fsharp
-// Position をルート長で割った余りを使用
-let currentStop (driver: Driver) : int =
-    driver.Route.[driver.Position % driver.Route.Length]
-
-// 例: ルート [1; 2; 3] の場合
-// Position 0 -> 停留所 1
-// Position 1 -> 停留所 2
-// Position 2 -> 停留所 3
-// Position 3 -> 停留所 1 (3 % 3 = 0)
-```
-
-```plantuml
-@startuml
-title 循環ルートの実現
-
-rectangle "ルート [1, 2, 3]" {
-  card "Position 0\n停留所 1" as p0
-  card "Position 1\n停留所 2" as p1
-  card "Position 2\n停留所 3" as p2
-  card "Position 3\n停留所 1" as p3
-  card "..." as dots
-  p0 --> p1
-  p1 --> p2
-  p2 --> p3
-  p3 --> dots
-}
-
-note bottom
-  Position % Route.Length で
-  循環を実現
-end note
-@enduml
-```
-
-## 3. 移動と噂の伝播
-
-### ワールド操作
-
-```fsharp
-/// ワールド = ドライバーのリスト
-type World = Driver list
-
-module World =
-    /// 全ドライバーを移動
-    let moveAll (world: World) : World =
-        List.map Driver.move world
-
-    /// 停留所ごとにドライバーをグループ化
-    let groupByStop (world: World) : Map<int, Driver list> =
-        world
-        |> List.groupBy Driver.currentStop
-        |> Map.ofList
-
-    /// 同じ停留所にいるドライバー間で噂を共有
-    let shareRumors (drivers: Driver list) : Driver list =
-        let allRumors =
-            drivers
-            |> List.map (fun d -> d.Rumors)
-            |> Set.unionMany
-        drivers
-        |> List.map (Driver.addRumors allRumors)
-
-    /// 全停留所で噂を伝播
-    let spreadRumors (world: World) : World =
-        world
-        |> groupByStop
-        |> Map.toList
-        |> List.map snd
-        |> List.map shareRumors
-        |> List.concat
-```
-
-### 噂の共有プロセス
-
-```plantuml
-@startuml
-title 噂の伝播プロセス
-
-participant "Driver 1" as d1
-participant "Stop" as stop
-participant "Driver 2" as d2
-
-d1 -> stop : 噂 {A, B}
-d2 -> stop : 噂 {C}
-
-stop -> stop : Set.unionMany
-note right: {A, B} ∪ {C} = {A, B, C}
-
-stop -> d1 : 噂 {A, B, C}
-stop -> d2 : 噂 {A, B, C}
-@enduml
-```
-
-## 4. シミュレーション
-
-### 1ステップの処理
-
-```fsharp
-/// 1ステップのシミュレーション
-/// 1. 全ドライバーを移動
-/// 2. 同じ停留所にいるドライバー間で噂を共有
-let drive (world: World) : World =
-    world
-    |> World.moveAll
-    |> World.spreadRumors
-```
-
-### 完了判定
-
-```fsharp
-/// 全ドライバーが同じ噂を持っているか確認
-let allRumorsShared (world: World) : bool =
-    match world with
-    | [] -> true
-    | first :: rest ->
-        rest |> List.forall (fun d -> d.Rumors = first.Rumors)
-```
-
-### シミュレーション実行
-
-```fsharp
-/// シミュレーション結果
-type SimulationResult =
-    | Completed of minutes: int
-    | Never
-
-/// 全噂が共有されるまでシミュレーション
-let driveTillAllRumorsSpread (maxMinutes: int) (world: World) : SimulationResult =
-    let rec loop (w: World) (time: int) =
-        if time > maxMinutes then
-            Never
-        elif World.allRumorsShared w then
-            Completed time
-        else
-            loop (drive w) (time + 1)
-    loop (drive world) 1
-
-/// 480分（8時間）を上限としてシミュレーション
-let simulate (world: World) : SimulationResult =
-    driveTillAllRumorsSpread 480 world
-```
-
-## 5. シーケンス図
-
-```plantuml
-@startuml
-title シミュレーションのフロー
-
-participant "Main" as main
-participant "World" as world
-participant "Drivers" as drivers
-participant "Stops" as stops
-
-main -> world : simulate
-activate world
-
-loop 全噂が共有されるまで（最大480回）
-  world -> drivers : moveAll
-  activate drivers
-  drivers --> world : 移動後のドライバー
-  deactivate drivers
-
-  world -> stops : groupByStop
-  activate stops
-  stops --> world : 停留所ごとのドライバー
-  deactivate stops
-
-  world -> world : spreadRumors
-  note right: 各停留所で噂を共有
-
-  world -> world : allRumorsShared?
-  alt 全噂が共有された
-    world --> main : Completed minutes
-  else 480分経過
-    world --> main : Never
-  end
-end
-
-deactivate world
-@enduml
-```
-
-## 6. 使用例
-
-```fsharp
-open FunctionalDesign.Part5.GossipingBusDrivers
-
-// 3人のドライバーを作成
-let world = [
-    Driver.create "D1" [3; 1; 2; 3] (Set.ofList ["rumor-a"])
-    Driver.create "D2" [3; 2; 3; 1] (Set.ofList ["rumor-b"])
-    Driver.create "D3" [4; 2; 3; 4; 5] (Set.ofList ["rumor-c"])
-]
-
-// シミュレーション実行
-match simulate world with
-| Completed minutes -> printfn "%d分で全噂が共有されました" minutes
-| Never -> printfn "8時間以内に全噂は共有されませんでした"
-
-// 絶対に出会わないルートの場合
-let neverMeet = [
-    Driver.create "D1" [1] (Set.ofList ["rumor-a"])
-    Driver.create "D2" [2] (Set.ofList ["rumor-b"])
-]
-
-match simulate neverMeet with
-| Never -> printfn "ドライバーは出会いません"
-| Completed _ -> printfn "予期しない結果"
-```
-
-## 7. 関数型アプローチの特徴
-
-### 不変データ構造
-
-すべての状態変更は新しいデータ構造を返します。元のデータは変更されません。
-
-```fsharp
-// ドライバーを移動しても元のドライバーは変更されない
-let original = Driver.create "Test" [1; 2; 3] (Set.ofList ["a"])
-let moved = Driver.move original
-
-Driver.currentStop original // 1 (変更なし)
-Driver.currentStop moved    // 2
-```
-
-### 集合演算の活用
-
-```fsharp
-// 複数の集合を統合
-let rumors1 = Set.ofList ["a"; "b"]
-let rumors2 = Set.ofList ["c"]
-let rumors3 = Set.ofList ["a"; "d"]
-
-Set.unionMany [rumors1; rumors2; rumors3]
-// Set ["a"; "b"; "c"; "d"]
-```
-
-### 純粋関数
-
-すべての関数は副作用がなく、同じ入力に対して常に同じ出力を返します。
-
-## 8. パターンの応用
-
-このパターンは以下のような場面で応用できます：
-
-- **ネットワーク伝播**: ウイルスや情報の拡散シミュレーション
-- **グラフ探索**: 巡回セールスマン問題の変形
-- **状態同期**: 分散システムでの状態共有
-
-## まとめ
-
-本章では、ゴシップ好きなバスの運転手問題を通じて以下を学びました：
-
-1. **循環ルート**: モジュロ演算による循環の実現
-2. **集合演算**: `Set.union`、`Set.unionMany` による状態の統合
-3. **データ変換パイプライン**: `|>` による処理の連鎖
-4. **終了条件の設計**: 再帰関数と条件分岐の組み合わせ
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part5/src/Library.fs`
-- テストコード: `apps/fsharp/part5/tests/Tests.fs`

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/16-payroll-system.md

@@ -1,359 +0,0 @@
----
-type: Article
-title: "第16章: 給与計算システム"
-description: "本章では、給与計算システムを通じて、関数型プログラミングで業務ドメインをモデリングする方法を学びます。"
-tags: [article, functional-desgin-ppp, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第16章: 給与計算システム
-
-## はじめに
-
-本章では、給与計算システムを通じて、関数型プログラミングで業務ドメインをモデリングする方法を学びます。異なる雇用形態（月給制、時給制、歩合制）に対応した給与計算を、判別共用体とパターンマッチングで実装します。
-
-## 1. 問題の説明
-
-給与計算システムは以下の要件を満たす必要があります：
-
-- **月給制従業員**: 固定の月給を支払う
-- **時給制従業員**: 労働時間に基づいて支払う（残業は1.5倍）
-- **歩合制従業員**: 基本給 + 売上に応じた歩合を支払う
-
-```plantuml
-@startuml
-title 給与計算システム
-
-class Employee {
-  +Id: string
-  +Name: string
-  +Type: EmployeeType
-}
-
-enum EmployeeType {
-  Salaried
-  Hourly
-  Commissioned
-}
-
-class TimeCard {
-  +Date: DateTime
-  +Hours: decimal
-}
-
-class SalesReceipt {
-  +Date: DateTime
-  +Amount: decimal
-}
-
-class Payslip {
-  +EmployeeId: string
-  +GrossPay: decimal
-  +PayDate: DateTime
-}
-
-Employee --> EmployeeType
-Employee "1" --> "*" TimeCard : 時給制のみ
-Employee "1" --> "*" SalesReceipt : 歩合制のみ
-Employee ..> Payslip : generates
-@enduml
-```
-
-## 2. データモデル
-
-### 従業員の種類
-
-```fsharp
-/// 従業員の種類
-[<RequireQualifiedAccess>]
-type EmployeeType =
-    | Salaried       // 月給制
-    | Hourly         // 時給制
-    | Commissioned   // 歩合制
-```
-
-### タイムカードと売上レシート
-
-```fsharp
-/// タイムカードエントリ
-type TimeCard =
-    { Date: DateTime
-      Hours: decimal }
-
-/// 売上レシート
-type SalesReceipt =
-    { Date: DateTime
-      Amount: decimal }
-```
-
-### 従業員
-
-```fsharp
-/// 従業員
-type Employee =
-    { Id: string
-      Name: string
-      Type: EmployeeType
-      Salary: decimal option          // 月給（Salaried, Commissionedの場合）
-      HourlyRate: decimal option      // 時給（Hourlyの場合）
-      CommissionRate: decimal option  // 歩合率（Commissionedの場合）
-      TimeCards: TimeCard list
-      SalesReceipts: SalesReceipt list }
-```
-
-## 3. 従業員作成
-
-```fsharp
-module Employee =
-    /// 月給制従業員を作成
-    let createSalaried (id: string) (name: string) (salary: decimal) : Employee =
-        { Id = id
-          Name = name
-          Type = EmployeeType.Salaried
-          Salary = Some salary
-          HourlyRate = None
-          CommissionRate = None
-          TimeCards = []
-          SalesReceipts = [] }
-
-    /// 時給制従業員を作成
-    let createHourly (id: string) (name: string) (hourlyRate: decimal) : Employee =
-        { Id = id
-          Name = name
-          Type = EmployeeType.Hourly
-          Salary = None
-          HourlyRate = Some hourlyRate
-          CommissionRate = None
-          TimeCards = []
-          SalesReceipts = [] }
-
-    /// 歩合制従業員を作成
-    let createCommissioned (id: string) (name: string) (salary: decimal) (commissionRate: decimal) : Employee =
-        { Id = id
-          Name = name
-          Type = EmployeeType.Commissioned
-          Salary = Some salary
-          HourlyRate = None
-          CommissionRate = Some commissionRate
-          TimeCards = []
-          SalesReceipts = [] }
-
-    /// タイムカードを追加
-    let addTimeCard (timeCard: TimeCard) (employee: Employee) : Employee =
-        { employee with TimeCards = timeCard :: employee.TimeCards }
-
-    /// 売上レシートを追加
-    let addSalesReceipt (receipt: SalesReceipt) (employee: Employee) : Employee =
-        { employee with SalesReceipts = receipt :: employee.SalesReceipts }
-```
-
-## 4. 給与計算
-
-### 計算ロジック
-
-```fsharp
-module Payroll =
-    /// 時給制の給与計算（8時間を超えると1.5倍）
-    let calculateHourlyPay (hourlyRate: decimal) (timeCards: TimeCard list) : decimal =
-        timeCards
-        |> List.sumBy (fun tc ->
-            let regularHours = min tc.Hours 8.0m
-            let overtimeHours = max (tc.Hours - 8.0m) 0.0m
-            (regularHours * hourlyRate) + (overtimeHours * hourlyRate * 1.5m))
-
-    /// 歩合制の給与計算
-    let calculateCommissionPay (baseSalary: decimal) (commissionRate: decimal) (receipts: SalesReceipt list) : decimal =
-        let totalSales = receipts |> List.sumBy (fun r -> r.Amount)
-        baseSalary + (totalSales * commissionRate)
-
-    /// 従業員の給与を計算
-    let calculatePay (employee: Employee) : decimal =
-        match employee.Type with
-        | EmployeeType.Salaried ->
-            employee.Salary |> Option.defaultValue 0m
-        | EmployeeType.Hourly ->
-            let rate = employee.HourlyRate |> Option.defaultValue 0m
-            calculateHourlyPay rate employee.TimeCards
-        | EmployeeType.Commissioned ->
-            let salary = employee.Salary |> Option.defaultValue 0m
-            let rate = employee.CommissionRate |> Option.defaultValue 0m
-            calculateCommissionPay salary rate employee.SalesReceipts
-```
-
-### 残業計算の図解
-
-```plantuml
-@startuml
-title 時給制の残業計算
-
-start
-:労働時間を取得;
-
-if (労働時間 > 8時間?) then (yes)
-  :通常時間 = 8時間;
-  :残業時間 = 労働時間 - 8;
-  :給与 = (8 × 時給) + (残業時間 × 時給 × 1.5);
-else (no)
-  :通常時間 = 労働時間;
-  :給与 = 労働時間 × 時給;
-endif
-
-:給与を返す;
-stop
-@enduml
-```
-
-## 5. 給与明細
-
-### 給与明細の定義
-
-```fsharp
-/// 給与明細
-type Payslip =
-    { EmployeeId: string
-      EmployeeName: string
-      EmployeeType: EmployeeType
-      GrossPay: decimal
-      PayDate: DateTime }
-```
-
-### 給与明細の生成
-
-```fsharp
-module Payslip =
-    /// 給与明細を生成
-    let generate (payDate: DateTime) (employee: Employee) : Payslip =
-        { EmployeeId = employee.Id
-          EmployeeName = employee.Name
-          EmployeeType = employee.Type
-          GrossPay = Payroll.calculatePay employee
-          PayDate = payDate }
-
-    /// 複数従業員の給与明細を生成
-    let generateAll (payDate: DateTime) (employees: Employee list) : Payslip list =
-        employees |> List.map (generate payDate)
-```
-
-## 6. シーケンス図
-
-```plantuml
-@startuml
-title 給与計算フロー
-
-participant "PayrollService" as service
-participant "Employee" as emp
-participant "Payroll" as payroll
-participant "Payslip" as slip
-
-service -> emp : 従業員情報取得
-activate emp
-emp --> service : Employee
-deactivate emp
-
-service -> payroll : calculatePay(employee)
-activate payroll
-
-alt 月給制
-  payroll -> payroll : return salary
-else 時給制
-  payroll -> payroll : calculateHourlyPay
-  note right: タイムカードから計算
-else 歩合制
-  payroll -> payroll : calculateCommissionPay
-  note right: 基本給 + 売上歩合
-end
-
-payroll --> service : 給与額
-deactivate payroll
-
-service -> slip : generate(payDate, employee)
-activate slip
-slip --> service : Payslip
-deactivate slip
-@enduml
-```
-
-## 7. 使用例
-
-```fsharp
-open System
-open FunctionalDesign.Part5.PayrollSystem
-
-// 月給制従業員
-let alice = Employee.createSalaried "E001" "Alice" 5000.0m
-let alicePay = Payroll.calculatePay alice
-// 5000.0m
-
-// 時給制従業員（残業あり）
-let bob =
-    Employee.createHourly "E002" "Bob" 25.0m
-    |> Employee.addTimeCard { Date = DateTime(2024, 1, 15); Hours = 10.0m }
-    |> Employee.addTimeCard { Date = DateTime(2024, 1, 16); Hours = 8.0m }
-let bobPay = Payroll.calculatePay bob
-// (8 * 25) + (2 * 25 * 1.5) + (8 * 25) = 200 + 75 + 200 = 475
-
-// 歩合制従業員
-let charlie =
-    Employee.createCommissioned "E003" "Charlie" 2000.0m 0.10m
-    |> Employee.addSalesReceipt { Date = DateTime(2024, 1, 15); Amount = 5000.0m }
-let charliePay = Payroll.calculatePay charlie
-// 2000 + 5000 * 0.10 = 2500
-
-// 給与明細の生成
-let payDate = DateTime(2024, 1, 31)
-let slips = Payslip.generateAll payDate [alice; bob; charlie]
-```
-
-## 8. 関数型アプローチの特徴
-
-### パターンマッチングによる分岐
-
-```fsharp
-match employee.Type with
-| EmployeeType.Salaried -> ...
-| EmployeeType.Hourly -> ...
-| EmployeeType.Commissioned -> ...
-```
-
-コンパイラが網羅性をチェックするため、新しい従業員タイプを追加した場合にすべての分岐を更新する必要があることが保証されます。
-
-### Option 型による安全な値アクセス
-
-```fsharp
-employee.Salary |> Option.defaultValue 0m
-```
-
-`null` チェックの代わりに `Option` 型を使用し、安全にデフォルト値を適用します。
-
-### イミュータブルなデータ操作
-
-```fsharp
-// 元のデータは変更されず、新しいデータが返される
-let updatedEmployee = Employee.addTimeCard timeCard employee
-```
-
-## 9. 拡張ポイント
-
-このシステムは以下のように拡張できます：
-
-- **税金計算**: 給与から税金を控除
-- **福利厚生**: 健康保険、年金などの控除
-- **支払いスケジュール**: 週払い、隔週払い、月払いの対応
-- **休暇管理**: 有給休暇の追跡と給与への反映
-
-## まとめ
-
-本章では、給与計算システムを通じて以下を学びました：
-
-1. **判別共用体**: 従業員タイプの表現
-2. **パターンマッチング**: 型に基づく給与計算の分岐
-3. **Option 型**: 安全な値アクセス
-4. **データ変換**: 従業員情報から給与明細への変換
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part5/src/Library.fs`
-- テストコード: `apps/fsharp/part5/tests/Tests.fs`