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

我正在尝试将Haskell核心库的Arrows转换为F#(我认为这是一个很好的练习,可以更好地理解Arrows和F#,我也许可以在我正在从事的项目中使用它们。)但是,直接翻译 由于范式的差异而无法实现。 Haskell使用类型类来表达这些内容,但是我不确定哪种F#构造的最佳方式将类型类的功能与F#的习语相映射。 我有一些想法,但最好将其提出来,看看在功能上最接近的东西。

对于tl人群:如何将类型类(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:模块,简单类型,让绑定

我的第一步是直接使用模块进行组织,例如:

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

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

那行得通,但是由于我没有实现类别,并且不能轻易实现更专业的Arrows,所以它在多态性上输了。

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

纠正“尝试1”中某些问题的一种方法是使用.fsi文件定义方法(这样,可以更轻松地强制执行类型),并使用一些简单的类型调整来进行专门化。

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

但是fsi文件不能在其他实现中重复使用(强制使用let绑定函数的类型),并且类型重命名/封装的东西很棘手。

尝试2:对象模型和接口

将F#也构建为面向对象也是合理的,也许类型层次结构是执行此操作的正确方法。

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:使用类型扩展进行优化

因此,另一种可能的改进是将接口声明为尽可能裸,然后使用扩展方法向所有实现类型添加功能。

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

嗯,但这使我无法对所有类型的IArrow使用一种方法。 如果我希望ListArrows稍有不同(&&&),该怎么办? 我还没有尝试过这种方法,但是我想我可以遮盖(&&&),或者至少提供一个更专业的版本,但是我觉得我不能强制使用正确的变体。

帮我

那我应该在这里做什么? 我觉得OO应该足够强大以替换类型类,但是我似乎无法弄清楚如何在F#中实现这一点。 我的任何尝试都结束了吗? 他们中的任何一个都“足够好”并且必须足够好吗?

2个解决方案
30 votes

我的简短回答是:

OO不足以替代类型类。

最直接的翻译是传递一个操作字典,就像在一个典型的typeclass实现中一样。 也就是说,如果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.Matthew do IG.com/?怕=112]

Brian answered 2020-08-02T09:54:14Z
21 votes

这是我用来模拟Typeclass的方法(来自[http://code.google.com/p/fsharp-typeclasses/])。

在您的情况下,对于Arrows可能是这样的:

let inline i2 (a:^a,b:^b     ) =                                                      
    ((^a or ^b      ) : (static member instance: ^a* ^b     -> _) (a,b  ))
let inline i3 (a:^a,b:^b,c:^c) =                                                          
    ((^a or ^b or ^c) : (static member instance: ^a* ^b* ^c -> _) (a,b,c))

type T = T with
    static member inline instance (a:'a      ) = 
        fun x -> i2(a   , Unchecked.defaultof<'r>) x :'r
    static member inline instance (a:'a, b:'b) = 
        fun x -> i3(a, b, Unchecked.defaultof<'r>) x :'r


type Return = Return with
    static member instance (_Monad:Return, _:option<'a>) = fun x -> Some x
    static member instance (_Monad:Return, _:list<'a>  ) = fun x  ->    [x]
    static member instance (_Monad:Return, _: 'r -> 'a ) = fun x _ ->    x
let inline return' x = T.instance Return x

type Bind = Bind with
    static member instance (_Monad:Bind, x:option<_>, _:option<'b>) = fun f -> 
        Option.bind  f x
    static member instance (_Monad:Bind, x:list<_>  , _:list<'b>  ) = fun f -> 
        List.collect f x
    static member instance (_Monad:Bind, f:'r->'a, _:'r->'b) = fun k r -> k (f r) r
let inline (>>=) x (f:_->'R) : 'R = T.instance (Bind, x) f
let inline (>=>) f g x    = f x >>= g

type Kleisli<'a, 'm> = Kleisli of ('a -> 'm)
let runKleisli (Kleisli f) = f

type Id = Id with
    static member        instance (_Category:Id, _: 'r -> 'r     ) = fun () -> id
    static member inline instance (_Category:Id, _:Kleisli<'a,'b>) = fun () ->
        Kleisli return'
let inline id'() = T.instance Id ()

type Comp = Comp with
    static member        instance (_Category:Comp,         f, _) = (<<) f
    static member inline instance (_Category:Comp, Kleisli f, _) =
        fun (Kleisli g) -> Kleisli (g >=> f)

let inline (<<<) f g = T.instance (Comp, f) g
let inline (>>>) g f = T.instance (Comp, f) g

type Arr = Arr with
    static member        instance (_Arrow:Arr, _: _ -> _) = fun (f:_->_) -> f
    static member inline instance (_Arrow:Arr, _:Kleisli<_,_>) = 
        fun f -> Kleisli (return' <<< f)
let inline arr f = T.instance Arr f

type First = First with
    static member        instance (_Arrow:First, f, _: 'a -> 'b) = 
        fun () (x,y) -> (f x, y)
    static member inline instance (_Arrow:First, Kleisli f, _:Kleisli<_,_>) =
        fun () -> Kleisli (fun (b,d) -> f b >>= fun c -> return' (c,d))
let inline first f = T.instance (First, f) ()

let inline second f = let swap (x,y) = (y,x) in arr swap >>> first f >>> arr swap
let inline ( *** ) f g = first f >>> second g
let inline ( &&& ) f g = arr (fun b -> (b,b)) >>> f *** g

用法:

> let f = Kleisli (fun y -> [y;y*2;y*3]) <<< Kleisli ( fun x -> [ x + 3 ; x * 2 ] ) ;;
val f : Kleisli<int,int list> = Kleisli <fun:f@4-14>

> runKleisli f <| 5 ;;
val it : int list = [8; 16; 24; 10; 20; 30]

> (arr (fun y -> [y;y*2;y*3])) 3 ;;
val it : int list = [3; 6; 9]

> let (x:option<_>) = runKleisli (arr (fun y -> [y;y*2;y*3])) 2 ;;
val x : int list option = Some [2; 4; 6]

> ( (*) 100) *** ((+) 9)   <| (5,10) ;;
val it : int * int = (500, 19)

> ( (*) 100) &&& ((+) 9)   <| 5 ;;
val it : int * int = (500, 14)

> let x:List<_>  = (runKleisli (id'())) 5 ;;
val x : List<int> = [5]

注意:使用id'()而不是id

更新:您需要F#3.0来编译此代码,否则,这是F#2.0版本。

这是对该技术的详细说明,该技术是类型安全的,可扩展的,并且您可以看到即使对于某些高级类型类型也可以使用。

Gus answered 2020-08-02T09:53:23Z
translate from https://stackoverflow.com:/questions/4034802/how-would-i-translate-a-haskell-type-class-into-f