@k2works/claude-code-booster 6.2.0 → 6.3.1

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/19-wator-simulation.md

@@ -1,412 +0,0 @@
----
-type: Article
-title: "第19章: Wa-Tor シミュレーション"
-description: "本章では、Wa-Tor（Water Torus）シミュレーションを通じて、セルオートマトンと判別共用体を使った捕食者-被食者モデルの実装を学びます。"
-tags: [article, functional-desgin-ppp, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-27T04:43:33Z }
----
-
-# 第19章: Wa-Tor シミュレーション
-
-## はじめに
-
-本章では、Wa-Tor（Water Torus）シミュレーションを通じて、セルオートマトンと判別共用体を使った捕食者-被食者モデルの実装を学びます。
-
-Wa-Tor は1984年に A.K. Dewdney が Scientific American で紹介した古典的なシミュレーションで、魚（被食者）とサメ（捕食者）の生態系をモデル化します。
-
-## 1. Wa-Tor の世界
-
-### トーラス型ワールド
-
-Wa-Tor の世界はトーラス（ドーナツ型）です。端に到達すると反対側に出現します。
-
-```plantuml
-@startuml
-title トーラス型ワールド
-
-rectangle "2D Grid" {
-  card "[0,0]" as c00
-  card "[1,0]" as c10
-  card "[2,0]" as c20
-  card "[0,1]" as c01
-  card "[1,1]" as c11
-  card "[2,1]" as c21
-  card "[0,2]" as c02
-  card "[1,2]" as c12
-  card "[2,2]" as c22
-}
-
-c00 --> c10
-c10 --> c20
-c20 --> c00 : wrap
-
-c00 --> c01
-c01 --> c02
-c02 --> c00 : wrap
-
-note bottom
-  端から端へワープする
-  例: [3,0] → [0,0]
-  例: [-1,0] → [2,0]
-end note
-@enduml
-```
-
-### セルの種類
-
-- **水（Water）**: 空のセル
-- **魚（Fish）**: 被食者、移動と繁殖のみ
-- **サメ（Shark）**: 捕食者、移動、繁殖、捕食
-
-## 2. データモデル
-
-### セルの定義
-
-```fsharp
-/// セルの種類
-[<RequireQualifiedAccess>]
-type Cell =
-    | Water
-    | Fish of age: int * breedTime: int
-    | Shark of age: int * breedTime: int * energy: int
-
-/// 座標
-type Position = int * int
-
-/// ワールド
-type World =
-    { Width: int
-      Height: int
-      Cells: Map<Position, Cell>
-      FishBreedTime: int
-      SharkBreedTime: int
-      SharkInitialEnergy: int
-      SharkEnergyFromFish: int }
-```
-
-判別共用体を使用することで、各セルの状態を型安全に表現できます。
-
-## 3. 座標操作
-
-### トーラス上での座標ラップ
-
-```fsharp
-module Position =
-    /// トーラス上で座標をラップ
-    let wrap (width: int) (height: int) ((x, y): Position) : Position =
-        ((x % width + width) % width, (y % height + height) % height)
-
-    /// 隣接セルの座標を取得（4方向）
-    let neighbors (width: int) (height: int) ((x, y): Position) : Position list =
-        [(x - 1, y); (x + 1, y); (x, y - 1); (x, y + 1)]
-        |> List.map (wrap width height)
-```
-
-```plantuml
-@startuml
-title 隣接セルの計算（4方向）
-
-rectangle "中央セル [2,2]" as center {
-}
-
-card "[1,2]" as left
-card "[3,2]" as right
-card "[2,1]" as up
-card "[2,3]" as down
-
-left --> center
-right --> center
-up --> center
-down --> center
-
-note bottom
-  4方向の隣接セルを取得
-  端ではラップアラウンド
-end note
-@enduml
-```
-
-## 4. ワールド操作
-
-```fsharp
-module World =
-    /// ワールドを作成
-    let create (width: int) (height: int) : World =
-        let positions = [ for x in 0..width-1 do for y in 0..height-1 -> (x, y) ]
-        let cells = positions |> List.map (fun pos -> (pos, Cell.Water)) |> Map.ofList
-        { Width = width
-          Height = height
-          Cells = cells
-          FishBreedTime = 3
-          SharkBreedTime = 8
-          SharkInitialEnergy = 5
-          SharkEnergyFromFish = 3 }
-
-    /// セルを取得
-    let getCell (pos: Position) (world: World) : Cell =
-        Map.tryFind pos world.Cells |> Option.defaultValue Cell.Water
-
-    /// セルを設定
-    let setCell (pos: Position) (cell: Cell) (world: World) : World =
-        { world with Cells = Map.add pos cell world.Cells }
-
-    /// 特定のセル種類の隣接セルを取得
-    let getNeighborsOfType (pos: Position) (predicate: Cell -> bool) (world: World) : Position list =
-        Position.neighbors world.Width world.Height pos
-        |> List.filter (fun p -> predicate (getCell p world))
-```
-
-## 5. シミュレーションルール
-
-### 魚のルール
-
-1. 隣接する空のセルにランダムに移動
-2. 一定時間（breedTime）経過後、繁殖（現在位置に子を残す）
-3. 移動できない場合はその場に留まる
-
-```fsharp
-/// 魚のティック処理
-let fishTick (pos: Position) (age: int) (breedTime: int) (world: World) : (Position * Cell) list =
-    let emptyNeighbors = World.getNeighborsOfType pos CellOps.isWater world
-    match pickRandom emptyNeighbors with
-    | Some newPos ->
-        if age + 1 >= breedTime then
-            // 繁殖: 現在位置に子を残し、新位置に移動
-            [ (pos, Cell.Fish(0, world.FishBreedTime))
-              (newPos, Cell.Fish(0, world.FishBreedTime)) ]
-        else
-            // 移動のみ
-            [ (pos, Cell.Water)
-              (newPos, Cell.Fish(age + 1, breedTime)) ]
-    | None ->
-        // 移動できない: その場で年を取る
-        [ (pos, Cell.Fish(age + 1, breedTime)) ]
-```
-
-### サメのルール
-
-1. 隣接する魚がいれば食べる（エネルギー獲得）
-2. 魚がいなければ空のセルに移動
-3. 毎ターン、エネルギーを1消費
-4. エネルギーが0になると死亡
-5. 一定時間経過後、繁殖
-
-```fsharp
-/// サメのティック処理
-let sharkTick (pos: Position) (age: int) (breedTime: int) (energy: int) (world: World) : (Position * Cell) list =
-    if energy <= 0 then
-        // エネルギー切れで死亡
-        [ (pos, Cell.Water) ]
-    else
-        let fishNeighbors = World.getNeighborsOfType pos CellOps.isFish world
-        let emptyNeighbors = World.getNeighborsOfType pos CellOps.isWater world
-
-        match pickRandom fishNeighbors with
-        | Some fishPos ->
-            // 魚を食べる
-            let newEnergy = energy + world.SharkEnergyFromFish
-            if age + 1 >= breedTime then
-                [ (pos, Cell.Shark(0, world.SharkBreedTime, world.SharkInitialEnergy))
-                  (fishPos, Cell.Shark(0, breedTime, newEnergy)) ]
-            else
-                [ (pos, Cell.Water)
-                  (fishPos, Cell.Shark(age + 1, breedTime, newEnergy)) ]
-        | None ->
-            match pickRandom emptyNeighbors with
-            | Some newPos ->
-                // 移動
-                ...
-            | None ->
-                // 移動できない
-                [ (pos, Cell.Shark(age + 1, breedTime, energy - 1)) ]
-```
-
-```plantuml
-@startuml
-title サメの行動フロー
-
-start
-:エネルギーを確認;
-
-if (エネルギー > 0?) then (yes)
-  if (隣接する魚がいる?) then (yes)
-    :魚を食べる;
-    :エネルギー獲得;
-  else (no)
-    if (空きセルがある?) then (yes)
-      :移動;
-    else (no)
-      :その場に留まる;
-    endif
-  endif
-  :エネルギー消費;
-  
-  if (繁殖時期?) then (yes)
-    :子を残す;
-  endif
-else (no)
-  :死亡（水に戻る）;
-endif
-
-stop
-@enduml
-```
-
-## 6. シミュレーション実行
-
-```fsharp
-module Simulation =
-    /// 1ステップ実行
-    let tick (world: World) : World =
-        let mutable newWorld = world
-
-        // 魚を処理
-        for pos in Map.toList world.Cells |> List.map fst do
-            match World.getCell pos newWorld with
-            | Cell.Fish(age, breedTime) ->
-                let updates = Rules.fishTick pos age breedTime newWorld
-                for (p, c) in updates do
-                    newWorld <- World.setCell p c newWorld
-            | _ -> ()
-
-        // サメを処理
-        for pos in Map.toList world.Cells |> List.map fst do
-            match World.getCell pos newWorld with
-            | Cell.Shark(age, breedTime, energy) ->
-                let updates = Rules.sharkTick pos age breedTime energy newWorld
-                for (p, c) in updates do
-                    newWorld <- World.setCell p c newWorld
-            | _ -> ()
-
-        newWorld
-
-    /// 複数ステップ実行
-    let run (steps: int) (world: World) : World =
-        let rec loop n w =
-            if n <= 0 then w
-            else loop (n - 1) (tick w)
-        loop steps world
-```
-
-## 7. 表示
-
-```fsharp
-module Display =
-    let cellToChar = function
-        | Cell.Water -> '.'
-        | Cell.Fish _ -> 'f'
-        | Cell.Shark _ -> 'S'
-
-    let worldToString (world: World) : string =
-        let sb = System.Text.StringBuilder()
-        for y in 0..world.Height-1 do
-            for x in 0..world.Width-1 do
-                sb.Append(cellToChar (World.getCell (x, y) world)) |> ignore
-            sb.AppendLine() |> ignore
-        sb.ToString()
-```
-
-出力例：
-```
-.....f....
-..S.......
-....f.....
-..f...S...
-..........
-```
-
-## 8. 使用例
-
-```fsharp
-open FunctionalDesign.Part6.WaTorSimulation
-
-// 10x10 のワールドを作成
-let world = World.create 10 10
-
-// 魚とサメを配置
-let world' =
-    world
-    |> World.placeFish (2, 2)
-    |> World.placeFish (3, 3)
-    |> World.placeFish (4, 4)
-    |> World.placeShark (5, 5)
-    |> World.placeShark (6, 6)
-
-// 初期状態を表示
-printfn "%s" (Display.worldToString world')
-
-// 統計情報
-let (fishCount, sharkCount, waterCount) = World.getStats world'
-printfn "Fish: %d, Sharks: %d, Water: %d" fishCount sharkCount waterCount
-
-// 10ステップ実行
-let final = Simulation.run 10 world'
-
-// 最終状態を表示
-printfn "%s" (Display.worldToString final)
-```
-
-## 9. 生態系のダイナミクス
-
-Wa-Tor シミュレーションは以下のような生態系のダイナミクスを示します：
-
-```plantuml
-@startuml
-title 捕食者-被食者ダイナミクス
-
-rectangle "Population" {
-  card "Fish (被食者)" as fish
-  card "Shark (捕食者)" as shark
-}
-
-fish --> shark : 捕食される
-shark --> shark : エネルギー獲得
-fish --> fish : 繁殖
-shark --> shark : 繁殖
-
-note right of fish
-  魚が増えすぎると
-  サメも増える
-end note
-
-note right of shark
-  サメが増えすぎると
-  魚が減りサメも減る
-end note
-@enduml
-```
-
-典型的なシナリオ：
-
-
-1. 魚の個体数が増加
-2. サメの餌が増え、サメも増加
-3. サメが増えすぎて魚が減少
-4. 餌不足でサメが減少
-5. 魚が再び増加（サイクルが繰り返される）
-
-## まとめ
-
-本章では、Wa-Tor シミュレーションを通じて以下を学びました：
-
-1. **セルオートマトン**: グリッドベースのシミュレーション
-2. **判別共用体**: セルの状態を型安全に表現
-3. **トーラス座標**: モジュロ演算によるラップアラウンド
-4. **生態系モデル**: 捕食者-被食者ダイナミクス
-
-## 第6部のまとめ
-
-第6部では、並行処理とシミュレーションについて学びました：
-
-- **並行処理システム**: 状態機械、イベントバス、MailboxProcessor
-- **Wa-Tor シミュレーション**: セルオートマトン、生態系モデル
-
-これらの技術は、複雑なシステムのモデリングと並行処理の実装に応用できます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part6/src/Library.fs`
-- テストコード: `apps/fsharp/part6/tests/Tests.fs`

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/20-pattern-interactions.md

@@ -1,300 +0,0 @@
----
-type: Article
-title: "第20章: パターン間の相互作用"
-description: "デザインパターンは単独で使用されることもありますが、実際のアプリケーションでは複数のパターンを組み合わせて使用することが一般的です。"
-tags: [article, functional-desgin-ppp, fsharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第20章: パターン間の相互作用
-
-## はじめに
-
-デザインパターンは単独で使用されることもありますが、実際のアプリケーションでは複数のパターンを組み合わせて使用することが一般的です。本章では、関数型プログラミングにおけるパターンの組み合わせ方と、その相乗効果について解説します。
-
-### 学習目標
-
-- Composite と Decorator パターンの組み合わせを理解する
-- Command と Observer パターンの連携を実装する
-- Strategy と Factory パターンの統合を学ぶ
-
-## 1. Composite + Decorator パターン
-
-### 基本概念
-
-**Composite パターン**は、オブジェクトを木構造で表現し、個別オブジェクトと複合オブジェクトを同一視できるようにします。
-
-**Decorator パターン**は、オブジェクトに動的に機能を追加します。
-
-これらを組み合わせることで、複合オブジェクトに対しても装飾を適用できます。
-
-```plantuml
-@startuml
-abstract class Shape {
-  +move(dx, dy)
-  +scale(factor)
-  +area()
-}
-
-class Circle {
-  +x: float
-  +y: float
-  +radius: float
-}
-
-class Rectangle {
-  +x: float
-  +y: float
-  +width: float
-  +height: float
-}
-
-class Composite {
-  +shapes: Shape list
-}
-
-class Journaled {
-  +shape: Shape
-  +journal: string list
-}
-
-class Colored {
-  +shape: Shape
-  +color: string
-}
-
-Shape <|.. Circle
-Shape <|.. Rectangle
-Shape <|.. Composite
-Shape <|.. Journaled
-Shape <|.. Colored
-
-Composite o-- Shape : contains
-Journaled o-- Shape : wraps
-Colored o-- Shape : wraps
-@enduml
-```
-
-### F# での実装
-
-```fsharp
-/// 図形（判別共用体で Composite + Decorator を表現）
-type Shape =
-    | Circle of x: float * y: float * radius: float
-    | Rectangle of x: float * y: float * width: float * height: float
-    | Composite of shapes: Shape list
-    | Journaled of shape: Shape * journal: string list
-    | Colored of shape: Shape * color: string
-    | Bordered of shape: Shape * borderWidth: float
-
-module Shape =
-    /// 図形を移動（再帰的に適用）
-    let rec move dx dy shape =
-        match shape with
-        | Circle(x, y, r) -> Circle(x + dx, y + dy, r)
-        | Rectangle(x, y, w, h) -> Rectangle(x + dx, y + dy, w, h)
-        | Composite shapes -> Composite(shapes |> List.map (move dx dy))
-        | Journaled(s, journal) ->
-            Journaled(move dx dy s, sprintf "moved(%.1f, %.1f)" dx dy :: journal)
-        | Colored(s, c) -> Colored(move dx dy s, c)
-        | Bordered(s, w) -> Bordered(move dx dy s, w)
-
-    /// 面積を計算（再帰的に適用）
-    let rec area shape =
-        match shape with
-        | Circle(_, _, r) -> System.Math.PI * r * r
-        | Rectangle(_, _, w, h) -> w * h
-        | Composite shapes -> shapes |> List.sumBy area
-        | Journaled(s, _) -> area s
-        | Colored(s, _) -> area s
-        | Bordered(s, _) -> area s
-```
-
-### 使用例
-
-```fsharp
-// 複合図形を作成
-let scene = Shape.composite [
-    Shape.circle 0.0 0.0 5.0
-    Shape.rectangle 10.0 10.0 20.0 15.0
-]
-
-// ジャーナル機能を追加
-let journaledScene = Shape.journaled scene
-
-// 移動と拡大を実行
-let final =
-    journaledScene
-    |> Shape.move 5.0 5.0
-    |> Shape.scale 2.0
-
-// 履歴を確認
-let history = Shape.getJournal final
-// ["scaled(2.0)"; "moved(5.0, 5.0)"]
-```
-
-## 2. Command + Observer パターン
-
-### 基本概念
-
-**Command パターン**は、操作をオブジェクトとしてカプセル化します。
-
-**Observer パターン**は、状態変更を購読者に通知します。
-
-これらを組み合わせることで、コマンド実行時に自動的に観察者へ通知できます。
-
-```plantuml
-@startuml
-class CommandExecutor {
-  +state: TState
-  +history: List
-  +observable: Observable
-  +execute(command)
-  +undo()
-}
-
-class Observable {
-  +observers: List<Observer>
-  +subscribe(observer)
-  +notify(value)
-}
-
-interface Observer {
-  +onUpdate(value)
-}
-
-CommandExecutor --> Observable
-Observable --> Observer
-@enduml
-```
-
-### F# での実装
-
-```fsharp
-/// オブザーバブル
-type Observable<'T> =
-    { Observers: Observer<'T> list }
-
-/// コマンド実行器
-type CommandExecutor<'TState> =
-    { State: 'TState
-      History: (Command<'TState> * 'TState) list
-      Observable: Observable<'TState> }
-
-module CommandExecutor =
-    let execute (command: Command<'TState>) (executor: CommandExecutor<'TState>) =
-        match command with
-        | Execute(exec, _) ->
-            let newState = exec executor.State
-            Observable.notify newState executor.Observable  // 観察者に通知
-            { executor with
-                State = newState
-                History = (command, executor.State) :: executor.History }
-        | _ -> executor
-
-    let subscribe (observer: Observer<'TState>) (executor: CommandExecutor<'TState>) =
-        { executor with Observable = Observable.subscribe observer executor.Observable }
-```
-
-### 使用例
-
-```fsharp
-// カウンターの例
-let mutable lastNotifiedValue = 0
-let observer = fun v -> lastNotifiedValue <- v
-
-let executor =
-    CommandExecutor.create 0
-    |> CommandExecutor.subscribe observer
-
-let addCommand = Execute((fun s -> s + 10), "add 10")
-let executor' = CommandExecutor.execute addCommand executor
-
-// lastNotifiedValue は 10 になる（自動通知）
-```
-
-## 3. Strategy + Factory パターン
-
-### 基本概念
-
-**Strategy パターン**は、アルゴリズムをカプセル化して交換可能にします。
-
-**Factory パターン**は、オブジェクト生成をカプセル化します。
-
-これらを組み合わせることで、条件に基づいて適切な戦略を自動選択できます。
-
-```plantuml
-@startuml
-class PricingFactory {
-  +createFromCustomer(type, amount)
-}
-
-abstract class PricingStrategy {
-  +calculate(amount)
-}
-
-class Regular
-class Discount
-class Member
-class Bulk
-
-PricingFactory --> PricingStrategy : creates
-PricingStrategy <|.. Regular
-PricingStrategy <|.. Discount
-PricingStrategy <|.. Member
-PricingStrategy <|.. Bulk
-@enduml
-```
-
-### F# での実装
-
-```fsharp
-/// 価格計算戦略
-type PricingStrategy =
-    | Regular
-    | Discount of rate: decimal
-    | Member of level: string
-    | Bulk of threshold: decimal * rate: decimal
-
-/// 戦略ファクトリ
-module PricingFactory =
-    let createFromCustomer (customerType: string) (purchaseAmount: decimal) : PricingStrategy =
-        match customerType with
-        | "guest" -> Regular
-        | "member" -> Member "bronze"
-        | "vip" -> Member "gold"
-        | "wholesale" when purchaseAmount > 10000m -> Bulk(10000m, 0.15m)
-        | _ -> Regular
-```
-
-### 使用例
-
-```fsharp
-// VIP 顧客には自動的にゴールド会員戦略を適用
-let strategy = PricingFactory.createFromCustomer "vip" 5000m
-let price = PricingStrategy.calculate strategy 1000m
-// 800m (20% 割引)
-
-// 卸売業者で大口注文には Bulk 戦略を適用
-let bulkStrategy = PricingFactory.createFromCustomer "wholesale" 15000m
-let bulkPrice = PricingStrategy.calculate bulkStrategy 15000m
-// 12750m (15% 割引)
-```
-
-## まとめ
-
-本章では、パターン間の相互作用について学びました：
-
-1. **Composite + Decorator**: 複合オブジェクトへの動的機能追加
-2. **Command + Observer**: コマンド実行と自動通知の連携
-3. **Strategy + Factory**: 条件に基づく戦略の自動選択
-
-パターンを組み合わせることで、より柔軟で保守性の高いシステムを構築できます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part7/src/Library.fs`
-- テストコード: `apps/fsharp/part7/tests/Tests.fs`