oop - 如何将 Haskell 类型类转换为 F#？

Question

我正在尝试将 Haskell 核心库的 Arrows 转换为 F#(我认为这是一个很好的练习，可以更好地理解 Arrows 和 F#，而且我也许可以在我正在从事的项目中使用它们。)但是，由于范式的差异，直接翻译是不可能的。 Haskell 使用类型类来表达这些东西，但我不确定 F# 的构造如何最好地将类型类的功能与 F# 的习惯用法映射起来。我有一些想法，但认为最好将其提出来，看看什么被认为是功能最接近的。

对于 tl;dr 人群:如何将类型类(Haskell 习惯用法)转换为 F# 惯用代码？

对于那些接受我的长解释的人:

Haskell 标准库中的这段代码是我尝试翻译的示例:

class Category cat where
    id :: cat a a
    comp :: cat a b -> cat b c -> cat a c
class Category a => Arrow a where
    arr :: (b -> c) -> a b c
    first :: a b c -> a (b,d) (c,d)

instance Category (->) where
    id f = f
instance Arrow (->) where
    arr f = f
    first f = f *** id

尝试 1:模块、简单类型、Let 绑定(bind)

我的第一个尝试是简单地直接使用模块进行组织映射，例如:

type Arrow<'a,'b> = Arrow of ('a -> 'b)

let arr f = Arrow f
let first f = //some code that does the first op

这可行，但它失去了多态性，因为我没有实现类别并且无法轻松实现更专业的箭头。

尝试 1a:使用签名和类型进行细化

纠正尝试 1 的一些问题的一种方法是使用 .fsi 文件来定义方法(以便类型更容易执行)并使用一些简单的类型调整来专门化。

type ListArrow<'a,'b> = Arrow<['a],['b]>
//or
type ListArrow<'a,'b> = LA of Arrow<['a],['b]>

但是 fsi 文件不能在其他实现中重用(以强制执行 let 绑定(bind)函数的类型)，并且类型重命名/封装内容很棘手。

尝试 2:对象模型和接口(interface)

合理解释 F# 也被构建为 OO，也许类型层次结构是实现此目的的正确方法。

type IArrow<'a,'b> =
    abstract member comp : IArrow<'b,'c> -> IArrow<'a,'c>
type Arrow<'a,'b>(func:'a->'b) = 
    interface IArrow<'a,'b> with
        member this.comp = //fun code involving "Arrow (fun x-> workOn x) :> IArrow"

除了让应该是静态方法(如 comp 和其他运算符)充当实例方法可能会很痛苦之外，还需要显式向上转换结果。我也不确定这种方法是否仍然能够捕获类型类多态性的完整表现力。这也使得使用必须是静态方法的东西变得困难。

尝试 2a:使用类型扩展进行细化

因此，另一个潜在的改进是尽可能简单地声明接口(interface)，然后使用扩展方法向所有实现类型添加功能。

type IArrow<'a,'b> with
    static member (&&&) f = //code to do the fanout operation

啊，但这让我不得不对所有类型的 IArrow 使用一种方法。如果我想为 ListArrows 使用稍微不同的 (&&&)，我该怎么办？我还没有尝试过这种方法，但我想我可以隐藏 (&&&)，或者至少提供一个更专业的版本，但我觉得我无法强制使用正确的变体。

帮帮我

那么我应该在这里做什么呢？我觉得 OO 应该足够强大来取代类型类，但我似乎不知道如何在 F# 中实现这一点。我的尝试是否接近？它们中的任何一个都“尽善尽美”并且必须足够好吗？

Answer 1

我的简短回答是:

OO 的功能还不足以取代类型类。

最直接的翻译是传递一个操作字典，就像在一个典型的类型类实现中一样。也就是说，如果 typeclass Foo 定义了三个方法，然后定义一个名为 Foo 的类/记录类型，然后更改

的函数

Foo a => yadda -> yadda -> yadda

像这样的函数

Foo -> yadda -> yadda -> yadda

并且在每个调用站点，您都知道根据调用站点的类型传递的具体“实例”。

以下是我的意思的一个简短示例:

// typeclass
type Showable<'a> = { show : 'a -> unit; showPretty : 'a -> unit } //'

// instances
let IntShowable = 
    { show = printfn "%d"; showPretty = (fun i -> printfn "pretty %d" i) }
let StringShowable = 
    { show = printfn "%s"; showPretty = (fun s -> printfn "<<%s>>" s) }

// function using typeclass constraint
// Showable a => [a] -> ()
let ShowAllPretty (s:Showable<'a>) l = //'
    l |> List.iter s.showPretty 

// callsites
ShowAllPretty IntShowable [1;2;3]
ShowAllPretty StringShowable ["foo";"bar"]

另请参阅

https://web.archive.org/web/20081017141728/http://blog.matthewdoig.com/?p=112