F＃針對多種類型的常見中綴運算符（fmap，applicative，bind等）

Question

我想要做的是使用中綴fmap（我定義爲< ^>）爲多種類型工作，如Option和Either（自定義類型）。

考慮：

type Either<'a, 'b> = Left of 'a | Right of 'b 

在代碼中，我希望能夠做到：

let fO (a : int option) = None 
    let fE (a : Either<string,int>) = Left "dummy" 

    let mO = Some 1 
    let mE = Right 1 

    let testO = f0 <^> m0 
    let testE = fE <^> mE 

其中每個（< ^>）：

let (<^>) f m = match m with | Some a -> Some <| f a | None -> None 
    let (<^>) f m = match m with | Right a -> Right <| f a | Left a -> Left a 

要獲得選項< ^>工作我已擴展模塊：

namespace Microsoft.FSharp.Core 
    [<AutoOpen>] 
    module Option = 
    let (<^>) f m = match m with | Some a -> Some <| f a | None -> None 

    [<assembly:AutoOpen("Microsoft.FSharp.Core")>] 
    do() 

以及針對：

type Either<'a, 'b> = Left of 'a | Right of 'b with 
     static member (<^>) (f,m) = match m with | Right a -> Right <| f a | Left a -> Left a 

這幾乎工程，但只有一個可以在同一時間使用。 任一模塊也可以附加到FSharp.Core，但同樣你也只能有一個或另一個。

我知道這可以用2個自定義類型完成，比如Either和Maybe（Haskell選項），但是我會堅持使用Option。

歡迎任何和所有建議。

Answer 1

這並不是真的很容易在F＃中表現出來，唯一的方法就是使用靜態解析的類型參數，而且它通常不被認爲是慣用的。

對於新的自定義類型，這樣做很容易，但是將其改造爲現有類型會更加複雜。再次支持兩者都稍微困難。

可以繼續進行下去的方法是創建一個輔助型單宗歧視工會與靜態方法硬編碼爲現有類型：

type Functor = Functor 
    with 
    static member FMap (Functor, mapper : 'T -> 'U, opt : Option<'T>) : Option<'U> = 
     Option.map mapper opt 
    static member FMap (Functor, mapper : 'T -> 'U, ch : Choice<'T, _>) : Choice<'U, _> = 
     match ch with 
     |Choice1Of2 v -> Choice1Of2 (mapper v) 
     |Choice2Of2 v -> Choice2Of2 v 

現在你可以使用函數與靜態解析型paramters到根據類型選擇合適的方法：

let inline fmap (f : ^c -> ^d) (x : ^a) = 
    ((^b or ^a) : (static member FMap : ^b * (^c -> ^d) * ^a -> ^e) (Functor, f, x)) 

請注意^b or ^a的條件？這也爲我們提供了一種將此行爲插入到自定義類型中的方法。

type Either<'a, 'b> = Left of 'a | Right of 'b with 
    static member FMap (Functor, f, m) = 
     match m with | Right a -> Right <| f a | Left a -> Left a 

對於運營商的形式，只是定義：

val inline fmap : 
    f:(^c -> ^d) -> x: ^a -> ^e 
    when (Functor or ^a) : (static member FMap : Functor * (^c -> ^d) * ^a -> ^e) 
val inline (<^>) : 
    f:(^a -> ^b) -> x: ^c -> ^d 
    when (Functor or ^c) : (static member FMap : Functor * (^a -> ^b) * ^c -> ^d) 

現在你可以做這種類型的事情與<^>操作：

let inline (<^>) f x = fmap f x 

您有定義的函數最終

let x = (fun x -> x + 1) <^> (Some 1) 
let x' = (fun x -> x + 1) <^> (None) 
let z<'a> : Either<'a, _> = (fun x -> x + 2) <^> (Right 2) 
let z' = (fun x -> x + 2) <^> (Left 5) 

---

另外，您可以查看F#+，以獲得對這些標準功能抽象的更完整實現。

Answer 2

爲了完整起見，最終實施

type Functor = Functor 
    with 
    static member FMap (Functor, mapper : 'T -> 'U, opt : Option<'T>) : Option<'U> = 
     Option.map mapper opt 
    static member FMap (Functor, mapper : 'T -> 'U, ch : Choice<'T, _>) : Choice<'U, _> = 
     match ch with 
     |Choice1Of2 v -> Choice1Of2 (mapper v) 
     |Choice2Of2 v -> Choice2Of2 v 

type Applicative = Applicative 
    with 
    static member Apply (Applicative, mapperInContext : Option<('T -> 'U)>, opt : Option<'T>) : Option<'U> = 
     match mapperInContext with | Some mapper -> Option.map mapper opt | _ -> None 
    static member Apply (Applicative, mapperInContext : Choice<_,_>, ch : Choice<'T,_>) : Choice<'U,_> = 
     match mapperInContext with 
     | Choice1Of2 mapper -> 
      match ch with 
      |Choice1Of2 v -> Choice1Of2 (mapper v) 
      |Choice2Of2 v -> Choice1Of2 v 
     | Choice2Of2 v -> Choice2Of2 v 

let inline fmap (f : ^c -> ^d) (x : ^a) = 
    ((^b or ^a) : (static member FMap : ^b * (^c -> ^d) * ^a -> ^e) (Functor, f, x)) 

let inline applicative (mf : ^f) (x : ^a) = 
    ((^b or ^a) : (static member Apply : ^b * ^f * ^a -> ^e) (Applicative, mf, x)) 

let inline (<^>) f x = fmap f x 

let inline (<*>) m x = applicative m x 

type Either<'a, 'b> = Left of 'a | Right of 'b with 
    static member FMap (Functor, f, m) = 
     match m with | Right a -> Right <| f a | Left a -> Left a 

    static member Apply (Applicative, fa, x) = match fa with | Right f -> Either<_, _>.FMap(Functor, f, x) | Left e -> Left e