如何在F#中用纯函数实现仅具备Db添加能力的服务并获取更新实例

我希望实现一个AddValueService，该服务仅能访问“向Db添加值”的能力，在服务逻辑中无法访问Db的其他函数；同时，调用该服务的逻辑后，我想要获取更新后的Db实例。请问是否可以实现？另外，如何在F#中用纯函数实现数据库能力方案？

以下是我的代码示例：

type Db = 
    | Db of Map<string, string>

let get id db =   
    let (Db dict) = db
    dict
    |> Map.tryFind id
    |> (fun x -> x, db)
    
let add id value db =
    let (Db dict) = db
    dict
    |> Map.add id value
    |> Db
    |> (fun x -> (), x)

let remove id db =
    let (Db dict) = db
    dict
    |> Map.remove id
    |> Db
    |> (fun x -> (), x)

type GetByIdCapability =
    | GetByIdCapability of ? (Id -> Value * ?) ?

type AddValueCapability =
    | AddValueCapability of ? (Id -> Value -> ?) ?

type RemoveByIdCapability =
    | RemoveByIdCapability of ? (Id -> ?) ?

type CreateAddValueCapability =
    | CreateAddValueCapability of (Db -> AddValueCapability)

type AddValueService =
    {
        AddValueCapability: AddValueCapability
    }

let createAddValueService db (CreateAddValueCapability createAddValueCapabilityFunc) =
    let addValueCapability = db |> createAddValueCapabilityFunc
    {
        AddValueCapability = addValueCapability
    }

let addValue id value (addValueService: AddValueService) =
    addValueService.AddValueCapability ?

1. 可行性说明 #

完全可以实现。核心思路是通过能力类型（Capability）封装对Db的操作，仅暴露允许的函数给服务，同时让操作返回更新后的Db实例。F#的纯函数特性天然支持这种模式，所有Db操作都是不可变的，每次修改都会生成新的Db实例，无副作用。

2. 完整纯函数实现代码 #

// 定义Db类型，保持内部Map的封装性
type Db = 
    | Db of Map<string, string>

// 基础Db操作函数，放在私有模块中限制外部直接访问
module private DbOps =
    let add id value (Db dict) =
        dict |> Map.add id value |> Db
    
    let get id (Db dict) =
        dict |> Map.tryFind id
    
    let remove id (Db dict) =
        dict |> Map.remove id |> Db

// 定义添加值的能力类型，仅封装允许的操作签名
type AddValueCapability =
    | AddValueCapability of (string -> string -> Db -> Db)

// 创建AddValue能力的函数，封装Db的add操作
let createAddValueCapability =
    AddValueCapability DbOps.add

// 定义AddValueService，仅持有AddValueCapability
type AddValueService =
    {
        AddValue: AddValueCapability
    }

// 创建服务的函数，注入AddValue能力
let createAddValueService (capability: AddValueCapability) =
    { AddValue = capability }

// 服务对外暴露的操作函数，调用能力并返回更新后的Db
let addValue id value db (service: AddValueService) =
    let (AddValueCapability addFunc) = service.AddValue
    addFunc id value db

3. 代码解释 #

• 封装Db内部操作：把Db的基础操作放在private模块DbOps里，外部无法直接访问get、remove等函数，只能通过暴露的能力类型间接操作。
• 能力类型的作用：AddValueCapability只封装了add操作的函数签名，服务持有这个能力后，只能执行添加操作，无法接触到Db的其他操作，严格限制了权限范围。
• 纯函数特性：所有操作都是不可变的，addFunc接收原Db实例，返回新的Db实例，没有任何副作用，完全符合纯函数要求。
• 使用示例：

// 初始化空Db
let initialDb = Db Map.empty

// 创建能力和服务
let addCapability = createAddValueCapability
let service = createAddValueService addCapability

// 调用服务添加值，获取更新后的Db
let updatedDb = addValue "user1" "Alice" initialDb service

4. 扩展说明 #

如果需要其他能力（比如查询、删除），可以定义对应的GetByIdCapability、RemoveByIdCapability，然后创建对应的服务或者组合服务。每个服务只持有自己需要的能力，严格遵循最小权限原则。

内容的提问来源于stack exchange，提问作者XaLVa