@k2works/claude-code-booster 4.6.0 → 4.7.0

package/lib/assets/docs/article/functional-desgin-ppp/fsharp/14-abstract-server-pattern.md

@@ -1,596 +1,596 @@
-# 第14章: Abstract Server パターン
-
-## はじめに
-
-Abstract Server パターンは、依存関係逆転の原則（DIP）を実現するパターンです。高レベルモジュールが低レベルモジュールの詳細に依存するのではなく、両者が抽象に依存することで疎結合を実現します。
-
-本章では、スイッチとデバイス、リポジトリとサービスの例を通じて、インターフェースによる Abstract Server パターンの実装を学びます。
-
-## 1. パターンの構造
-
-Abstract Server パターンは以下の要素で構成されます：
-
-- **Client**: サービスを利用するモジュール
-- **Abstract Server**: サービスの抽象インターフェース
-- **Concrete Server**: 具体的なサービスの実装
-
-```plantuml
-@startuml
-skinparam classAttributeIconSize 0
-
-class "Client\n(Switch)" as client {
-  +engage(device)
-  +disengage(device)
-  +toggle(device)
-}
-
-interface "Abstract Server\n(ISwitchable)" as abstract {
-  +TurnOn()
-  +TurnOff()
-  +IsOn
-}
-
-class "Concrete Server\n(Light)" as light {
-  +State
-  +TurnOn()
-  +TurnOff()
-  +IsOn
-}
-
-class "Concrete Server\n(Fan)" as fan {
-  +State
-  +Speed
-  +TurnOn()
-  +TurnOff()
-  +IsOn
-}
-
-class "Concrete Server\n(Motor)" as motor {
-  +State
-  +Direction
-  +TurnOn()
-  +TurnOff()
-  +IsOn
-}
-
-client --> abstract : depends on
-light ..|> abstract
-fan ..|> abstract
-motor ..|> abstract
-
-note right of client
-  Clientは抽象に依存します。
-  具体的な実装を知りません。
-end note
-
-note right of abstract
-  Abstract Serverは
-  インターフェースを定義します。
-  F#ではinterfaceを使用します。
-end note
-@enduml
-```
-
-## 2. ISwitchable インターフェース
-
-### Abstract Server の定義
-
-```fsharp
-/// スイッチ可能なデバイスのインターフェース
-type ISwitchable =
-    abstract member TurnOn: unit -> ISwitchable
-    abstract member TurnOff: unit -> ISwitchable
-    abstract member IsOn: bool
-```
-
-F# のインターフェースは、メソッドを定義する abstract member として宣言します。イミュータブルな実装のため、`TurnOn` と `TurnOff` は新しい `ISwitchable` を返します。
-
-## 3. Concrete Server: Light
-
-### 実装
-
-```fsharp
-type Light =
-    { State: bool }
-    interface ISwitchable with
-        member this.TurnOn() = { State = true } :> ISwitchable
-        member this.TurnOff() = { State = false } :> ISwitchable
-        member this.IsOn = this.State
-
-module Light =
-    let create () = { State = false }
-    let createOn () = { State = true }
-```
-
-Light はレコード型として定義し、`ISwitchable` インターフェースを実装します。`:>` 演算子で基底型へのアップキャストを行います。
-
-## 4. Concrete Server: Fan
-
-### 実装
-
-```fsharp
-[<RequireQualifiedAccess>]
-type FanSpeed = | Low | Medium | High
-
-type Fan =
-    { State: bool
-      Speed: FanSpeed option }
-    interface ISwitchable with
-        member this.TurnOn() = { State = true; Speed = Some FanSpeed.Low } :> ISwitchable
-        member this.TurnOff() = { State = false; Speed = None } :> ISwitchable
-        member this.IsOn = this.State
-
-module Fan =
-    let create () = { State = false; Speed = None }
-    let setSpeed (speed: FanSpeed) (fan: Fan) =
-        if fan.State then { fan with Speed = Some speed }
-        else fan
-```
-
-Fan はスピード設定を持つデバイスです。`[<RequireQualifiedAccess>]` 属性により、`FanSpeed.Low` のように修飾名でアクセスします。
-
-## 5. Concrete Server: Motor
-
-### 実装
-
-```fsharp
-[<RequireQualifiedAccess>]
-type MotorDirection = | Forward | Reverse
-
-type Motor =
-    { State: bool
-      Direction: MotorDirection option }
-    interface ISwitchable with
-        member this.TurnOn() = { State = true; Direction = Some MotorDirection.Forward } :> ISwitchable
-        member this.TurnOff() = { State = false; Direction = None } :> ISwitchable
-        member this.IsOn = this.State
-
-module Motor =
-    let create () = { State = false; Direction = None }
-    let reverse (motor: Motor) =
-        if motor.State then
-            let newDir =
-                match motor.Direction with
-                | Some MotorDirection.Forward -> Some MotorDirection.Reverse
-                | Some MotorDirection.Reverse -> Some MotorDirection.Forward
-                | None -> Some MotorDirection.Forward
-            { motor with Direction = newDir }
-        else motor
-```
-
-Motor は方向を持つデバイスで、`reverse` 関数で方向を反転できます。
-
-## 6. Client: Switch
-
-### 実装
-
-```fsharp
-module Switch =
-    /// スイッチを入れる
-    let engage (device: ISwitchable) : ISwitchable =
-        device.TurnOn()
-
-    /// スイッチを切る
-    let disengage (device: ISwitchable) : ISwitchable =
-        device.TurnOff()
-
-    /// スイッチを切り替える
-    let toggle (device: ISwitchable) : ISwitchable =
-        if device.IsOn then device.TurnOff()
-        else device.TurnOn()
-
-    /// デバイスの状態を取得
-    let status (device: ISwitchable) : string =
-        if device.IsOn then "ON" else "OFF"
-```
-
-### 使用例
-
-```fsharp
-// 同じSwitchコードで異なるデバイスを操作
-let light = Light.create ()
-let lightOn = Switch.engage (light :> ISwitchable)
-printfn "%s" (Switch.status lightOn) // "ON"
-
-let fan = Fan.create ()
-let fanOn = Switch.engage (fan :> ISwitchable)
-printfn "%s" (Switch.status fanOn) // "ON"
-
-let motor = Motor.create ()
-let motorOn = Switch.engage (motor :> ISwitchable)
-printfn "%s" (Switch.status motorOn) // "ON"
-```
-
-## 7. シーケンス図
-
-```plantuml
-@startuml
-actor Client
-participant "Switch" as switch
-participant "ISwitchable\n(Interface)" as interface
-participant "Light" as light
-participant "Fan" as fan
-
-== Light の操作 ==
-Client -> switch : engage(light)
-activate switch
-switch -> interface : TurnOn(light)
-activate interface
-interface -> light : TurnOn()
-activate light
-light --> interface : updated-light
-deactivate light
-interface --> switch : updated-light
-deactivate interface
-switch --> Client : light-on
-deactivate switch
-
-== Fan の操作 ==
-Client -> switch : engage(fan)
-activate switch
-switch -> interface : TurnOn(fan)
-activate interface
-interface -> fan : TurnOn()
-activate fan
-fan --> interface : updated-fan
-deactivate fan
-interface --> switch : updated-fan
-deactivate interface
-switch --> Client : fan-on
-deactivate switch
-
-note right
-  Switchは具体的なデバイスを
-  知らずに操作できます。
-  ISwitchableインターフェースを通じて
-  多態的に動作します。
-end note
-@enduml
-```
-
-## 8. Repository の例
-
-### Abstract Server: IRepository インターフェース
-
-```fsharp
-/// リポジトリインターフェース
-type IRepository<'TEntity, 'TId> =
-    abstract member FindById: 'TId -> 'TEntity option
-    abstract member FindAll: unit -> 'TEntity list
-    abstract member Save: 'TEntity -> 'TEntity
-    abstract member Delete: 'TId -> bool
-```
-
-ジェネリック型パラメータを使用して、任意のエンティティと ID 型に対応します。
-
-### Concrete Server: MemoryUserRepository
-
-```fsharp
-type User =
-    { Id: string
-      Name: string
-      Email: string
-      CreatedAt: System.DateTime }
-
-type MemoryUserRepository(initialData: Map<string, User>) =
-    let mutable data = initialData
-
-    interface IRepository<User, string> with
-        member _.FindById(id) = Map.tryFind id data
-        member _.FindAll() = data |> Map.toList |> List.map snd
-        member _.Save(user) =
-            let userId = if user.Id = "" then System.Guid.NewGuid().ToString() else user.Id
-            let userWithId = { user with Id = userId }
-            data <- Map.add userId userWithId data
-            userWithId
-        member _.Delete(id) =
-            if Map.containsKey id data then
-                data <- Map.remove id data
-                true
-            else false
-
-module MemoryUserRepository =
-    let create () = MemoryUserRepository(Map.empty)
-```
-
-### Client: UserService
-
-```fsharp
-module UserService =
-    /// ユーザーを作成
-    let createUser (repo: IRepository<User, string>) (name: string) (email: string) : User =
-        let user =
-            { Id = ""
-              Name = name
-              Email = email
-              CreatedAt = System.DateTime.UtcNow }
-        repo.Save(user)
-
-    /// ユーザーを取得
-    let getUser (repo: IRepository<User, string>) (id: string) : User option =
-        repo.FindById(id)
-
-    /// 全ユーザーを取得
-    let getAllUsers (repo: IRepository<User, string>) : User list =
-        repo.FindAll()
-
-    /// ユーザーを削除
-    let deleteUser (repo: IRepository<User, string>) (id: string) : bool =
-        repo.Delete(id)
-```
-
-## 9. 依存関係の図
-
-```plantuml
-@startuml
-skinparam classAttributeIconSize 0
-
-package "Application Layer" {
-  class "UserService" as service {
-    +createUser(repo, name, email)
-    +getUser(repo, id)
-    +getAllUsers(repo)
-  }
-}
-
-package "Domain Layer" {
-  interface "IRepository" as repo {
-    +FindById(id)
-    +FindAll()
-    +Save(entity)
-    +Delete(id)
-  }
-}
-
-package "Infrastructure Layer" {
-  class "MemoryUserRepository" as memRepo {
-    +data: Map
-    +FindById(id)
-    +FindAll()
-    +Save(entity)
-    +Delete(id)
-  }
-
-  class "DatabaseRepository" as dbRepo {
-    +connection
-    +FindById(id)
-    +FindAll()
-    +Save(entity)
-    +Delete(id)
-  }
-}
-
-service --> repo : depends on
-memRepo ..|> repo
-dbRepo ..|> repo
-
-note right of service
-  UserServiceはIRepositoryインターフェースに
-  依存します。具体的な実装は
-  実行時に注入されます。
-end note
-
-note bottom of memRepo
-  テスト時はMemoryUserRepository、
-  本番時はDatabaseRepositoryを
-  使用できます。
-end note
-@enduml
-```
-
-## 10. 関数型アプローチ：レコード＋関数
-
-F# では、インターフェースの代わりにレコード型で関数を束ねる方法もあります：
-
-```fsharp
-/// 関数型リポジトリ
-type FunctionalRepository<'TEntity, 'TId> =
-    { FindById: 'TId -> 'TEntity option
-      FindAll: unit -> 'TEntity list
-      Save: 'TEntity -> 'TEntity
-      Delete: 'TId -> bool }
-
-module FunctionalRepository =
-    /// インメモリリポジトリを作成
-    let createInMemory<'TId, 'TEntity when 'TId: comparison>
-        (getId: 'TEntity -> 'TId)
-        (setId: 'TId -> 'TEntity -> 'TEntity)
-        (generateId: unit -> 'TId)
-        : FunctionalRepository<'TEntity, 'TId> =
-        let mutable data: Map<'TId, 'TEntity> = Map.empty
-        { FindById = fun id -> Map.tryFind id data
-          FindAll = fun () -> data |> Map.toList |> List.map snd
-          Save = fun entity ->
-              let entityId = if getId entity = Unchecked.defaultof<'TId> then generateId() else getId entity
-              let entityWithId = setId entityId entity
-              data <- Map.add entityId entityWithId data
-              entityWithId
-          Delete = fun id ->
-              if Map.containsKey id data then
-                  data <- Map.remove id data
-                  true
-              else false }
-```
-
-使用例：
-
-```fsharp
-type SimpleUser = { Id: int; Name: string }
-
-let mutable nextId = 1
-let repo = FunctionalRepository.createInMemory<int, SimpleUser>
-               (fun u -> u.Id)
-               (fun id u -> { u with Id = id })
-               (fun () ->
-                   let id = nextId
-                   nextId <- nextId + 1
-                   id)
-
-let user = repo.Save { Id = 0; Name = "Alice" }
-let found = repo.FindById user.Id
-```
-
-## 11. Logger と Cache の例
-
-### ILogger インターフェース
-
-```fsharp
-[<RequireQualifiedAccess>]
-type LogLevel = | Debug | Info | Warning | Error
-
-type ILogger =
-    abstract member Log: LogLevel -> string -> unit
-    abstract member Debug: string -> unit
-    abstract member Info: string -> unit
-    abstract member Warning: string -> unit
-    abstract member Error: string -> unit
-
-type BufferedLogger() =
-    let mutable logs: (LogLevel * string * System.DateTime) list = []
-
-    interface ILogger with
-        member _.Log level message =
-            logs <- (level, message, System.DateTime.UtcNow) :: logs
-        member this.Debug message = (this :> ILogger).Log LogLevel.Debug message
-        member this.Info message = (this :> ILogger).Log LogLevel.Info message
-        member this.Warning message = (this :> ILogger).Log LogLevel.Warning message
-        member this.Error message = (this :> ILogger).Log LogLevel.Error message
-
-    member _.GetLogs() = List.rev logs
-    member _.Clear() = logs <- []
-
-type NullLogger() =
-    interface ILogger with
-        member _.Log _ _ = ()
-        member _.Debug _ = ()
-        member _.Info _ = ()
-        member _.Warning _ = ()
-        member _.Error _ = ()
-```
-
-### ICache インターフェース
-
-```fsharp
-type ICache<'TKey, 'TValue> =
-    abstract member Get: 'TKey -> 'TValue option
-    abstract member Set: 'TKey -> 'TValue -> unit
-    abstract member Remove: 'TKey -> bool
-    abstract member Clear: unit -> unit
-
-type MemoryCache<'TKey, 'TValue when 'TKey: comparison>() =
-    let mutable data: Map<'TKey, 'TValue> = Map.empty
-
-    interface ICache<'TKey, 'TValue> with
-        member _.Get key = Map.tryFind key data
-        member _.Set key value = data <- Map.add key value data
-        member _.Remove key =
-            if Map.containsKey key data then
-                data <- Map.remove key data
-                true
-            else false
-        member _.Clear() = data <- Map.empty
-```
-
-## 12. 依存性注入コンテナ
-
-シンプルな DI コンテナの実装例：
-
-```fsharp
-type ServiceContainer() =
-    let mutable services: Map<string, obj> = Map.empty
-
-    member _.Register<'T>(key: string) (service: 'T) =
-        services <- Map.add key (box service) services
-
-    member _.Resolve<'T>(key: string) : 'T option =
-        Map.tryFind key services |> Option.map (fun s -> s :?> 'T)
-
-    member _.RegisterSingleton<'T>(service: 'T) =
-        let key = typeof<'T>.FullName
-        services <- Map.add key (box service) services
-
-    member _.ResolveSingleton<'T>() : 'T option =
-        let key = typeof<'T>.FullName
-        Map.tryFind key services |> Option.map (fun s -> s :?> 'T)
-```
-
-## 13. パターンの利点
-
-1. **疎結合**: クライアントは具体的な実装を知らない
-2. **テスト容易性**: モック/スタブを簡単に注入可能
-3. **柔軟性**: 実装の交換が容易
-4. **依存関係逆転**: 高レベルモジュールが低レベルモジュールに依存しない
-
-## 14. F# での特徴
-
-F# での Abstract Server パターンの実装には以下の特徴があります：
-
-1. **インターフェース**: 抽象サーバーを定義
-2. **レコード型 + インターフェース実装**: 具体的なサーバーを実装
-3. **イミュータブル**: 状態変更は新しいレコードを返す
-4. **依存性注入**: 関数の引数としてインターフェースを渡す
-
-```plantuml
-@startuml
-title F# での Abstract Server
-
-rectangle "インターフェース (interface)" {
-  card "ISwitchable" as switchable
-  card "IRepository" as repo
-}
-
-rectangle "レコード + インターフェース実装" {
-  card "Light" as light
-  card "Fan" as fan
-  card "MemoryUserRepository" as memRepo
-}
-
-rectangle "クライアントモジュール" {
-  card "Switch.engage" as engage
-  card "UserService.createUser" as create
-}
-
-engage --> switchable : 依存
-create --> repo : 依存
-light ..|> switchable : 実装
-fan ..|> switchable : 実装
-memRepo ..|> repo : 実装
-
-note bottom
-  インターフェースを使って抽象化し、
-  レコードやクラスで具体的な実装を提供します。
-  クライアントはインターフェースにのみ依存します。
-end note
-@enduml
-```
-
-## まとめ
-
-本章では、Abstract Server パターンについて学びました：
-
-1. **インターフェースによる抽象化**: ISwitchable、IRepository、ILogger、ICache
-2. **レコード/クラスによる実装**: Light、Fan、Motor、MemoryUserRepository
-3. **クライアントの独立性**: Switch、UserService
-4. **依存関係逆転**: 高レベルモジュールが抽象に依存
-5. **関数型アプローチ**: レコード型で関数を束ねる方法
-
-Abstract Server パターンは、モジュール間の疎結合を実現し、テスト容易性と柔軟性を向上させます。
-
-## 参考コード
-
-本章のコード例は以下のファイルで確認できます：
-
-- ソースコード: `apps/fsharp/part4/src/Library.fs`
-- テストコード: `apps/fsharp/part4/tests/Tests.fs`
-
-## 第4部のまとめ
-
-第4部では、デザインパターンについて学びました：
-
-- **Strategy パターン**: アルゴリズムをカプセル化して交換可能にする
-- **Command パターン**: 操作をオブジェクトとしてカプセル化
-- **Visitor パターン**: データ構造と処理を分離
-- **Abstract Factory パターン**: 関連するオブジェクトのファミリーを一貫して生成
-- **Abstract Server パターン**: 依存関係逆転による疎結合の実現
-
-これらのパターンは、モジュールの独立性を高め、テスト容易性と保守性を向上させます。
+# 第14章: Abstract Server パターン
+
+## はじめに
+
+Abstract Server パターンは、依存関係逆転の原則（DIP）を実現するパターンです。高レベルモジュールが低レベルモジュールの詳細に依存するのではなく、両者が抽象に依存することで疎結合を実現します。
+
+本章では、スイッチとデバイス、リポジトリとサービスの例を通じて、インターフェースによる Abstract Server パターンの実装を学びます。
+
+## 1. パターンの構造
+
+Abstract Server パターンは以下の要素で構成されます：
+
+- **Client**: サービスを利用するモジュール
+- **Abstract Server**: サービスの抽象インターフェース
+- **Concrete Server**: 具体的なサービスの実装
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+class "Client\n(Switch)" as client {
+  +engage(device)
+  +disengage(device)
+  +toggle(device)
+}
+
+interface "Abstract Server\n(ISwitchable)" as abstract {
+  +TurnOn()
+  +TurnOff()
+  +IsOn
+}
+
+class "Concrete Server\n(Light)" as light {
+  +State
+  +TurnOn()
+  +TurnOff()
+  +IsOn
+}
+
+class "Concrete Server\n(Fan)" as fan {
+  +State
+  +Speed
+  +TurnOn()
+  +TurnOff()
+  +IsOn
+}
+
+class "Concrete Server\n(Motor)" as motor {
+  +State
+  +Direction
+  +TurnOn()
+  +TurnOff()
+  +IsOn
+}
+
+client --> abstract : depends on
+light ..|> abstract
+fan ..|> abstract
+motor ..|> abstract
+
+note right of client
+  Clientは抽象に依存します。
+  具体的な実装を知りません。
+end note
+
+note right of abstract
+  Abstract Serverは
+  インターフェースを定義します。
+  F#ではinterfaceを使用します。
+end note
+@enduml
+```
+
+## 2. ISwitchable インターフェース
+
+### Abstract Server の定義
+
+```fsharp
+/// スイッチ可能なデバイスのインターフェース
+type ISwitchable =
+    abstract member TurnOn: unit -> ISwitchable
+    abstract member TurnOff: unit -> ISwitchable
+    abstract member IsOn: bool
+```
+
+F# のインターフェースは、メソッドを定義する abstract member として宣言します。イミュータブルな実装のため、`TurnOn` と `TurnOff` は新しい `ISwitchable` を返します。
+
+## 3. Concrete Server: Light
+
+### 実装
+
+```fsharp
+type Light =
+    { State: bool }
+    interface ISwitchable with
+        member this.TurnOn() = { State = true } :> ISwitchable
+        member this.TurnOff() = { State = false } :> ISwitchable
+        member this.IsOn = this.State
+
+module Light =
+    let create () = { State = false }
+    let createOn () = { State = true }
+```
+
+Light はレコード型として定義し、`ISwitchable` インターフェースを実装します。`:>` 演算子で基底型へのアップキャストを行います。
+
+## 4. Concrete Server: Fan
+
+### 実装
+
+```fsharp
+[<RequireQualifiedAccess>]
+type FanSpeed = | Low | Medium | High
+
+type Fan =
+    { State: bool
+      Speed: FanSpeed option }
+    interface ISwitchable with
+        member this.TurnOn() = { State = true; Speed = Some FanSpeed.Low } :> ISwitchable
+        member this.TurnOff() = { State = false; Speed = None } :> ISwitchable
+        member this.IsOn = this.State
+
+module Fan =
+    let create () = { State = false; Speed = None }
+    let setSpeed (speed: FanSpeed) (fan: Fan) =
+        if fan.State then { fan with Speed = Some speed }
+        else fan
+```
+
+Fan はスピード設定を持つデバイスです。`[<RequireQualifiedAccess>]` 属性により、`FanSpeed.Low` のように修飾名でアクセスします。
+
+## 5. Concrete Server: Motor
+
+### 実装
+
+```fsharp
+[<RequireQualifiedAccess>]
+type MotorDirection = | Forward | Reverse
+
+type Motor =
+    { State: bool
+      Direction: MotorDirection option }
+    interface ISwitchable with
+        member this.TurnOn() = { State = true; Direction = Some MotorDirection.Forward } :> ISwitchable
+        member this.TurnOff() = { State = false; Direction = None } :> ISwitchable
+        member this.IsOn = this.State
+
+module Motor =
+    let create () = { State = false; Direction = None }
+    let reverse (motor: Motor) =
+        if motor.State then
+            let newDir =
+                match motor.Direction with
+                | Some MotorDirection.Forward -> Some MotorDirection.Reverse
+                | Some MotorDirection.Reverse -> Some MotorDirection.Forward
+                | None -> Some MotorDirection.Forward
+            { motor with Direction = newDir }
+        else motor
+```
+
+Motor は方向を持つデバイスで、`reverse` 関数で方向を反転できます。
+
+## 6. Client: Switch
+
+### 実装
+
+```fsharp
+module Switch =
+    /// スイッチを入れる
+    let engage (device: ISwitchable) : ISwitchable =
+        device.TurnOn()
+
+    /// スイッチを切る
+    let disengage (device: ISwitchable) : ISwitchable =
+        device.TurnOff()
+
+    /// スイッチを切り替える
+    let toggle (device: ISwitchable) : ISwitchable =
+        if device.IsOn then device.TurnOff()
+        else device.TurnOn()
+
+    /// デバイスの状態を取得
+    let status (device: ISwitchable) : string =
+        if device.IsOn then "ON" else "OFF"
+```
+
+### 使用例
+
+```fsharp
+// 同じSwitchコードで異なるデバイスを操作
+let light = Light.create ()
+let lightOn = Switch.engage (light :> ISwitchable)
+printfn "%s" (Switch.status lightOn) // "ON"
+
+let fan = Fan.create ()
+let fanOn = Switch.engage (fan :> ISwitchable)
+printfn "%s" (Switch.status fanOn) // "ON"
+
+let motor = Motor.create ()
+let motorOn = Switch.engage (motor :> ISwitchable)
+printfn "%s" (Switch.status motorOn) // "ON"
+```
+
+## 7. シーケンス図
+
+```plantuml
+@startuml
+actor Client
+participant "Switch" as switch
+participant "ISwitchable\n(Interface)" as interface
+participant "Light" as light
+participant "Fan" as fan
+
+== Light の操作 ==
+Client -> switch : engage(light)
+activate switch
+switch -> interface : TurnOn(light)
+activate interface
+interface -> light : TurnOn()
+activate light
+light --> interface : updated-light
+deactivate light
+interface --> switch : updated-light
+deactivate interface
+switch --> Client : light-on
+deactivate switch
+
+== Fan の操作 ==
+Client -> switch : engage(fan)
+activate switch
+switch -> interface : TurnOn(fan)
+activate interface
+interface -> fan : TurnOn()
+activate fan
+fan --> interface : updated-fan
+deactivate fan
+interface --> switch : updated-fan
+deactivate interface
+switch --> Client : fan-on
+deactivate switch
+
+note right
+  Switchは具体的なデバイスを
+  知らずに操作できます。
+  ISwitchableインターフェースを通じて
+  多態的に動作します。
+end note
+@enduml
+```
+
+## 8. Repository の例
+
+### Abstract Server: IRepository インターフェース
+
+```fsharp
+/// リポジトリインターフェース
+type IRepository<'TEntity, 'TId> =
+    abstract member FindById: 'TId -> 'TEntity option
+    abstract member FindAll: unit -> 'TEntity list
+    abstract member Save: 'TEntity -> 'TEntity
+    abstract member Delete: 'TId -> bool
+```
+
+ジェネリック型パラメータを使用して、任意のエンティティと ID 型に対応します。
+
+### Concrete Server: MemoryUserRepository
+
+```fsharp
+type User =
+    { Id: string
+      Name: string
+      Email: string
+      CreatedAt: System.DateTime }
+
+type MemoryUserRepository(initialData: Map<string, User>) =
+    let mutable data = initialData
+
+    interface IRepository<User, string> with
+        member _.FindById(id) = Map.tryFind id data
+        member _.FindAll() = data |> Map.toList |> List.map snd
+        member _.Save(user) =
+            let userId = if user.Id = "" then System.Guid.NewGuid().ToString() else user.Id
+            let userWithId = { user with Id = userId }
+            data <- Map.add userId userWithId data
+            userWithId
+        member _.Delete(id) =
+            if Map.containsKey id data then
+                data <- Map.remove id data
+                true
+            else false
+
+module MemoryUserRepository =
+    let create () = MemoryUserRepository(Map.empty)
+```
+
+### Client: UserService
+
+```fsharp
+module UserService =
+    /// ユーザーを作成
+    let createUser (repo: IRepository<User, string>) (name: string) (email: string) : User =
+        let user =
+            { Id = ""
+              Name = name
+              Email = email
+              CreatedAt = System.DateTime.UtcNow }
+        repo.Save(user)
+
+    /// ユーザーを取得
+    let getUser (repo: IRepository<User, string>) (id: string) : User option =
+        repo.FindById(id)
+
+    /// 全ユーザーを取得
+    let getAllUsers (repo: IRepository<User, string>) : User list =
+        repo.FindAll()
+
+    /// ユーザーを削除
+    let deleteUser (repo: IRepository<User, string>) (id: string) : bool =
+        repo.Delete(id)
+```
+
+## 9. 依存関係の図
+
+```plantuml
+@startuml
+skinparam classAttributeIconSize 0
+
+package "Application Layer" {
+  class "UserService" as service {
+    +createUser(repo, name, email)
+    +getUser(repo, id)
+    +getAllUsers(repo)
+  }
+}
+
+package "Domain Layer" {
+  interface "IRepository" as repo {
+    +FindById(id)
+    +FindAll()
+    +Save(entity)
+    +Delete(id)
+  }
+}
+
+package "Infrastructure Layer" {
+  class "MemoryUserRepository" as memRepo {
+    +data: Map
+    +FindById(id)
+    +FindAll()
+    +Save(entity)
+    +Delete(id)
+  }
+
+  class "DatabaseRepository" as dbRepo {
+    +connection
+    +FindById(id)
+    +FindAll()
+    +Save(entity)
+    +Delete(id)
+  }
+}
+
+service --> repo : depends on
+memRepo ..|> repo
+dbRepo ..|> repo
+
+note right of service
+  UserServiceはIRepositoryインターフェースに
+  依存します。具体的な実装は
+  実行時に注入されます。
+end note
+
+note bottom of memRepo
+  テスト時はMemoryUserRepository、
+  本番時はDatabaseRepositoryを
+  使用できます。
+end note
+@enduml
+```
+
+## 10. 関数型アプローチ：レコード＋関数
+
+F# では、インターフェースの代わりにレコード型で関数を束ねる方法もあります：
+
+```fsharp
+/// 関数型リポジトリ
+type FunctionalRepository<'TEntity, 'TId> =
+    { FindById: 'TId -> 'TEntity option
+      FindAll: unit -> 'TEntity list
+      Save: 'TEntity -> 'TEntity
+      Delete: 'TId -> bool }
+
+module FunctionalRepository =
+    /// インメモリリポジトリを作成
+    let createInMemory<'TId, 'TEntity when 'TId: comparison>
+        (getId: 'TEntity -> 'TId)
+        (setId: 'TId -> 'TEntity -> 'TEntity)
+        (generateId: unit -> 'TId)
+        : FunctionalRepository<'TEntity, 'TId> =
+        let mutable data: Map<'TId, 'TEntity> = Map.empty
+        { FindById = fun id -> Map.tryFind id data
+          FindAll = fun () -> data |> Map.toList |> List.map snd
+          Save = fun entity ->
+              let entityId = if getId entity = Unchecked.defaultof<'TId> then generateId() else getId entity
+              let entityWithId = setId entityId entity
+              data <- Map.add entityId entityWithId data
+              entityWithId
+          Delete = fun id ->
+              if Map.containsKey id data then
+                  data <- Map.remove id data
+                  true
+              else false }
+```
+
+使用例：
+
+```fsharp
+type SimpleUser = { Id: int; Name: string }
+
+let mutable nextId = 1
+let repo = FunctionalRepository.createInMemory<int, SimpleUser>
+               (fun u -> u.Id)
+               (fun id u -> { u with Id = id })
+               (fun () ->
+                   let id = nextId
+                   nextId <- nextId + 1
+                   id)
+
+let user = repo.Save { Id = 0; Name = "Alice" }
+let found = repo.FindById user.Id
+```
+
+## 11. Logger と Cache の例
+
+### ILogger インターフェース
+
+```fsharp
+[<RequireQualifiedAccess>]
+type LogLevel = | Debug | Info | Warning | Error
+
+type ILogger =
+    abstract member Log: LogLevel -> string -> unit
+    abstract member Debug: string -> unit
+    abstract member Info: string -> unit
+    abstract member Warning: string -> unit
+    abstract member Error: string -> unit
+
+type BufferedLogger() =
+    let mutable logs: (LogLevel * string * System.DateTime) list = []
+
+    interface ILogger with
+        member _.Log level message =
+            logs <- (level, message, System.DateTime.UtcNow) :: logs
+        member this.Debug message = (this :> ILogger).Log LogLevel.Debug message
+        member this.Info message = (this :> ILogger).Log LogLevel.Info message
+        member this.Warning message = (this :> ILogger).Log LogLevel.Warning message
+        member this.Error message = (this :> ILogger).Log LogLevel.Error message
+
+    member _.GetLogs() = List.rev logs
+    member _.Clear() = logs <- []
+
+type NullLogger() =
+    interface ILogger with
+        member _.Log _ _ = ()
+        member _.Debug _ = ()
+        member _.Info _ = ()
+        member _.Warning _ = ()
+        member _.Error _ = ()
+```
+
+### ICache インターフェース
+
+```fsharp
+type ICache<'TKey, 'TValue> =
+    abstract member Get: 'TKey -> 'TValue option
+    abstract member Set: 'TKey -> 'TValue -> unit
+    abstract member Remove: 'TKey -> bool
+    abstract member Clear: unit -> unit
+
+type MemoryCache<'TKey, 'TValue when 'TKey: comparison>() =
+    let mutable data: Map<'TKey, 'TValue> = Map.empty
+
+    interface ICache<'TKey, 'TValue> with
+        member _.Get key = Map.tryFind key data
+        member _.Set key value = data <- Map.add key value data
+        member _.Remove key =
+            if Map.containsKey key data then
+                data <- Map.remove key data
+                true
+            else false
+        member _.Clear() = data <- Map.empty
+```
+
+## 12. 依存性注入コンテナ
+
+シンプルな DI コンテナの実装例：
+
+```fsharp
+type ServiceContainer() =
+    let mutable services: Map<string, obj> = Map.empty
+
+    member _.Register<'T>(key: string) (service: 'T) =
+        services <- Map.add key (box service) services
+
+    member _.Resolve<'T>(key: string) : 'T option =
+        Map.tryFind key services |> Option.map (fun s -> s :?> 'T)
+
+    member _.RegisterSingleton<'T>(service: 'T) =
+        let key = typeof<'T>.FullName
+        services <- Map.add key (box service) services
+
+    member _.ResolveSingleton<'T>() : 'T option =
+        let key = typeof<'T>.FullName
+        Map.tryFind key services |> Option.map (fun s -> s :?> 'T)
+```
+
+## 13. パターンの利点
+
+1. **疎結合**: クライアントは具体的な実装を知らない
+2. **テスト容易性**: モック/スタブを簡単に注入可能
+3. **柔軟性**: 実装の交換が容易
+4. **依存関係逆転**: 高レベルモジュールが低レベルモジュールに依存しない
+
+## 14. F# での特徴
+
+F# での Abstract Server パターンの実装には以下の特徴があります：
+
+1. **インターフェース**: 抽象サーバーを定義
+2. **レコード型 + インターフェース実装**: 具体的なサーバーを実装
+3. **イミュータブル**: 状態変更は新しいレコードを返す
+4. **依存性注入**: 関数の引数としてインターフェースを渡す
+
+```plantuml
+@startuml
+title F# での Abstract Server
+
+rectangle "インターフェース (interface)" {
+  card "ISwitchable" as switchable
+  card "IRepository" as repo
+}
+
+rectangle "レコード + インターフェース実装" {
+  card "Light" as light
+  card "Fan" as fan
+  card "MemoryUserRepository" as memRepo
+}
+
+rectangle "クライアントモジュール" {
+  card "Switch.engage" as engage
+  card "UserService.createUser" as create
+}
+
+engage --> switchable : 依存
+create --> repo : 依存
+light ..|> switchable : 実装
+fan ..|> switchable : 実装
+memRepo ..|> repo : 実装
+
+note bottom
+  インターフェースを使って抽象化し、
+  レコードやクラスで具体的な実装を提供します。
+  クライアントはインターフェースにのみ依存します。
+end note
+@enduml
+```
+
+## まとめ
+
+本章では、Abstract Server パターンについて学びました：
+
+1. **インターフェースによる抽象化**: ISwitchable、IRepository、ILogger、ICache
+2. **レコード/クラスによる実装**: Light、Fan、Motor、MemoryUserRepository
+3. **クライアントの独立性**: Switch、UserService
+4. **依存関係逆転**: 高レベルモジュールが抽象に依存
+5. **関数型アプローチ**: レコード型で関数を束ねる方法
+
+Abstract Server パターンは、モジュール間の疎結合を実現し、テスト容易性と柔軟性を向上させます。
+
+## 参考コード
+
+本章のコード例は以下のファイルで確認できます：
+
+- ソースコード: `apps/fsharp/part4/src/Library.fs`
+- テストコード: `apps/fsharp/part4/tests/Tests.fs`
+
+## 第4部のまとめ
+
+第4部では、デザインパターンについて学びました：
+
+- **Strategy パターン**: アルゴリズムをカプセル化して交換可能にする
+- **Command パターン**: 操作をオブジェクトとしてカプセル化
+- **Visitor パターン**: データ構造と処理を分離
+- **Abstract Factory パターン**: 関連するオブジェクトのファミリーを一貫して生成
+- **Abstract Server パターン**: 依存関係逆転による疎結合の実現
+
+これらのパターンは、モジュールの独立性を高め、テスト容易性と保守性を向上させます。