Types 跨不同类型共享功能

如果f#编写了一个etl过程，它将在关系数据库中排序的数据转换为星型模式，为第三方平台做好准备。因为我们正在对数据进行非规范化，所以在我们的系统中有（几乎）重复的对象、类型和属性。到目前为止，我一直对此感到满意，因为对象的不同足以保证不同的功能，或者我们能够将公共/共享属性分组到子记录中

但是，我们现在添加的对象需要拾取和选择系统的不同部分，并且不属于现有的公共分组。 在尝试了几种不同的风格后，我开始使用界面，但使用它们时感觉有些不对劲。有没有人遇到过这个问题并提出了不同的方法

module rec MyModels =
    type AccountType1 =
        { Id : int
          Error : string option 
          Name : string option }
        // PROBLEM: this get very bulky as more properties are shared
        interface Props.Error<AccountType1> with member x.Optic = (fun _ -> x.Error), (fun v -> { x with Error = v })
        interface Props.AccountId<AccountType1> with member x.Optic = (fun _ -> x.Id), (fun v -> { x with Id = v })
        interface Props.AccountName<AccountType1> with member x.Optic = (fun _ -> x.Name), (fun v -> { x with Name = v })

    type AccountType2 =
        { Id : int
          Error : string option 
          AccountId : int
          AccountName : string option
          OtherValue : string }
        interface Props.Error<AccountType2> with member x.Optic = (fun _ -> x.Error), (fun v -> { x with Error = v })
        interface Props.AccountId<AccountType2> with member x.Optic = (fun _ -> x.AccountId), (fun v -> { x with AccountId = v })
        interface Props.AccountName<AccountType2> with member x.Optic = (fun _ -> x.AccountName), (fun v -> { x with AccountName = v })
        interface Props.OtherValue<AccountType2> with member x.Optic = (fun _ -> x.OtherValue), (fun v -> { x with OtherValue = v })

    module Props =
        type OpticProp<'a,'b> = (unit -> 'a) * ('a -> 'b)    

        // Common properties my models can share
        // (I know they should start with an I)

        type Error<'a> = abstract member Optic : OpticProp<string option, 'a>
        let Error (h : Error<_>) = h.Optic

        type AccountId<'a> = abstract member Optic : OpticProp<int, 'a>
        let AccountId (h : AccountId<_>) = h.Optic

        type AccountName<'a> = abstract member Optic : OpticProp<string option, 'a>
        let AccountName (h : AccountName<_>) = h.Optic

        type OtherValue<'a> = abstract member Optic : OpticProp<string, 'a>
        let OtherValue (h : OtherValue<_>) = h.Optic

[<RequireQualifiedAccess>]
module Optics =
    // Based on Aether
    module Operators =
        let inline (^.) o optic = (optic o |> fst) ()
        let inline (^=) value optic = fun o ->  (optic o |> snd) value

    let inline get optic o =
        let get, _ = optic o
        get ()

    let inline set optic v (o : 'a) : 'a = 
        let _, set = optic o
        set v

open MyModels
open Optics.Operators

// Common functions that change the models

let error msg item =
    item
    |> (Some msg)^=Props.Error
    |> Error

let accountName item = 
    match item^.Props.AccountId with
    | 1 -> 
        item
        |> (Some "Account 1")^=Props.AccountName
        |> Ok
    | 2 -> 
        item
        |> (Some "Account 2")^=Props.AccountName
        |> Ok
    | _ ->
        item
        |> error "Can't find account"

let correctAccount item =
    match item^.Props.AccountName with
    | Some "Account 1" -> Ok item
    | _ ->
        item
        |> error "This is not Account 1"

let otherValue lookup item =
    let value = lookup ()

    item
    |> value^=Props.OtherValue
    |> Ok

// Build the transform pipeline

let inline (>=>) a b =
    fun value ->
    match a value with
    | Ok result -> b result
    | Error error -> Error error


let account1TransformPipeline lookups = // Lookups can be passed around is needed
    accountName
    >=> correctAccount

let account2TransformPipeline lookups =
    accountName
    >=> correctAccount
    >=> otherValue lookups

// Try out the pipelines

let account1 = 
    ({ Id = 1; Error = None; Name = None } : AccountType1)
    |> account1TransformPipeline ()

let account2 = 
    ({ Id = 1; Error = None; AccountId = 1; AccountName = None; OtherValue = "foo" } : AccountType2)
    |> account2TransformPipeline (fun () -> "bar")

module rec MyModels=
类型AccountType1=
{Id:int
错误：字符串选项
名称：字符串选项}
//问题：随着更多的属性被共享，这会变得非常庞大
接口Props.Error与成员x.Optic=（fun->x.Error），（fun v->{x与Error=v}）
接口Props.AccountId与成员x.Optic=（fun->x.Id），（fun v->{x，Id=v}）
接口Props.AccountName与成员x.Optic=（fun->x.Name），（fun v->{x，Name=v}）
类型AccountType2=
{Id:int
错误：字符串选项
帐号：int
AccountName:string选项
OtherValue:string}
接口Props.Error与成员x.Optic=（fun->x.Error），（fun v->{x与Error=v}）
接口Props.AccountId与成员x.Optic=（fun->x.AccountId），（fun v->{x与AccountId=v}）
接口Props.AccountName与成员x.Optic=（fun->x.AccountName），（fun v->{x与AccountName=v}）
接口Props.OtherValue与成员x.Optic=（fun->x.OtherValue），（fun v->{x与OtherValue=v}）
模块道具=
输入opticrop=（单位->'a）*（'a->'b）
//我的模型可以共享的公共属性
//（我知道他们应该以I开头）
类型错误
let误差（h:误差）=h.光学
类型AccountId
让AccountId（h:AccountId）=h
键入AccountName
让AccountName（h:AccountName）=h
键入其他值
设OtherValue（h:OtherValue）=h.光学
[]
模块光学=
//基于乙醚
模运算符=
让内联（^.）o光学=（光学o |>fst）（）
让内联（^=）值optic=fun o->（optic o|>snd）值
让我们来看看你的眼睛=
让我们开始吧
得到（）
让内联设置光学v（o:'a）：'a=
设为光学o
第五组
打开MyModels
开放光学。操作员
//更改模型的常用函数
让错误消息项=
项目
|>（一些消息）^=Props.Error
|>错误
让accountName项目=
将项目^.Props.AccountId与匹配
| 1 -> 
项目
|>（某些“帐户1”）^=Props.AccountName
|>嗯
| 2 -> 
项目
|>（某些“帐户2”）^=Props.AccountName
|>嗯
| _ ->
项目
|>错误“找不到帐户”
让我们考虑一下这个项目=
将项目^.Props.AccountName与匹配
|某些“科目1”->Ok项
| _ ->
项目
|>错误“这不是帐户1”
让otherValue查找项=
让值=查找（）
项目
|>value^=Props.OtherValue
|>嗯
//构建转换管道
让内联（>=>）a b=
趣味价值->
将值与匹配
|确定结果->b结果
|错误->错误错误
let account1TransformPipeline lookups=//如果需要，可以传递查找
帐户名
>=>更正帐户
让Account2传输MPipeline查找=
帐户名
>=>更正帐户
>=>其他值查找
//试试管道
让account1=
（{Id=1；Error=None；Name=None}:AccountType1）
|>会计科目1转移支付（）
让account2=
（{Id=1；Error=None；AccountId=1；AccountName=None；OtherValue=“foo”}:AccountType2）
|>Account2Transfermpipeline（乐趣（）->“酒吧”）

还有一件事我试过了：

• 以太光学-除非我遗漏了一些东西，这只是为了编辑 不适用于公共特性的复杂对象的子类型
• Duck打字–我很喜欢这种方式，但问题是你必须太内联 多功能

---

我真的不知道如何使您的解决方案更简单-我认为在您的方法中非常奇特地使用类型使得代码非常复杂。在保持某种类型的键入的同时，可能还有其他方法来简化此过程。同样，我认为在某些情况下，您需要实现的逻辑是相当动态的，因此可能值得使用一些更动态的技术，即使是在F#中

举个例子，下面是一个使用。这使您可以将数据表示为数据帧（列名为字符串）

在数据帧上编写所需的两个清理操作相对容易-库针对基于列的操作进行了优化，因此代码结构与您的代码结构略有不同（我们计算新列，然后替换数据帧中的所有行）：

然后，您的管道可以获取记录，将其转换为数据帧并执行所有处理：

[ { Id = 1; Error = None; Name = None } ]
|> Frame.ofRecords
|> correctAccount "Id" "Name"

[ { Id = 1; Error = None; AccountId = 1; AccountName = None; OtherValue = "foo" } ]
|> Frame.ofRecords
|> correctAccount "Id" "AccountName"
|> otherValue "bar"

---

这种方法的类型安全性不如您的方法，但我相信人们实际上可以阅读代码并了解代码的功能，这可能值得权衡。

您可以看看。我认为您的接口很好。SRTP（duck typing）会让事情变得更糟。事实上，我做了一些非常类似的事情……但我自动生成了大部分代码。我同意，lens‘只是让代码难以阅读，这不是一个部分困难的问题，但现在看起来它与所有光学元件都一样……它与ado.net datase类似

[ { Id = 1; Error = None; Name = None } ]
|> Frame.ofRecords
|> correctAccount "Id" "Name"

[ { Id = 1; Error = None; AccountId = 1; AccountName = None; OtherValue = "foo" } ]
|> Frame.ofRecords
|> correctAccount "Id" "AccountName"
|> otherValue "bar"