如何將`where T：U`通用類型參數約束從C＃轉換爲F＃？

Question

F＃給我的類型推理規則帶來一些麻煩。我正在編寫一個簡單的計算生成器，但無法正確獲取我的泛型類型變量約束。

---

，我想代碼看起來在C＃如下：

class FinallyBuilder<TZ> 
{ 
    readonly Action<TZ> finallyAction; 

    public FinallyBuilder(Action<TZ> finallyAction) 
    { 
     this.finallyAction = finallyAction; 
    } 

    public TB Bind<TA, TB>(TA x, Func<TA, TB> cont) where TA : TZ 
    {          //  ^^^^^^^^^^^^^ 
     try        // this is what gives me a headache 
     {         //  in the F# version 
      return cont(x); 
     } 
     finally 
     { 
      finallyAction(x); 
     } 
    } 
} 

---

最好的（但非編譯代碼）我已經拿出了F＃版本到目前爲止是：

type FinallyBuilder<′z> (finallyAction : ′z -> unit) = 

    member this.Bind (x : ′a) (cont : ′a -> ′b) = 
     try  cont x 
     finally finallyAction (x :> ′z) // cast illegal due to missing constraint 

// Note: ' changed to ′ to avoid bad syntax highlighting here on SO. 

Unfortu最近，我不知道如何翻譯Bind方法的where TA : TZ類型約束。我認爲它應該是類似於′a when ′a :> ′z，但F＃編譯器不喜歡這個地方，我總是最終得到一些泛型類型變量約束到另一個。

難道有人請讓我看看正確的F＃代碼嗎？

---

背景：我的目標是能寫的F＃的定製工作流程是這樣的：

let cleanup = new FinallyBuilder (fun x -> ...) 

cleanup { 
    let! x = ... // x and y will be passed to the above lambda function at 
    let! y = ... // the end of this block; x and y can have different types! 
} 

Answer 1

我不認爲有可能在F＃中寫這樣的約束（儘管我不完全確定爲什麼）。無論如何，syntacticalaly，你想寫這樣的事情（如布賴恩建議）：

type FinallyBuilder<'T> (finallyAction : 'T -> unit) = 
    member this.Bind<'A, 'B when 'A :> 'T>(x : 'A) (cont : 'A -> 'B) = //' 
    try cont x 
    finally finallyAction (x :> 'T) 

可惜的是，這提供了以下錯誤：

error FS0698: Invalid constraint: the type used for the constraint is sealed, which means the constraint could only be satisfied by at most one solution

這似乎是相同的情況下，作爲一個在this mailing list中討論過。當唐·賽姆說以下內容：

This is a restriction imposed to make F# type inference tractable. In particular, the type on the right of a subtype constraint must be nominal. Note constraints of the form 'A :> 'B are always eagerly solved to 'A = 'B, as specified in section 14.6 of the F# specification.

您可以通過在傳遞給你的建設者功能使用obj總是解決這個問題。
編輯：即使使用obj，使用let!綁定的值將有更具體的類型（主叫finallyAction時，F＃會自動施放某種類型的參數來obj值）：

type FinallyBuilder(finallyAction : obj -> unit) = 
    member x.Bind(v, f) = 
    try f v 
    finally finallyAction v 
    member x.Return(v) = v 

let cleanup = FinallyBuilder(printfn "%A") 

let res = 
    cleanup { let! a = new System.Random() 
      let! b = "hello" 
      return 3 } 

Answer 2

它將會像

...Bind<'A when 'A :> 'Z>... 

但讓我代碼時以確保這是完全正確的...

啊，它看起來就像它會是這樣：

type FinallyBuilder<'z> (finallyAction : 'z -> unit) = 
    member this.Bind<'a, 'b when 'a :> 'z> (x : 'a, cont : 'a -> 'b) : 'b = 
     try  cont x 
     finally finallyAction x //(x :> 'z)// illegal 

除了

http://cs.hubfs.net/forums/thread/10527.aspx

指出F＃不做形式「T1：> T2」的約束上，其中兩者都是類型變量（它假定T1 = T2）。然而，對於你的情況，這可能是確定的，你打算用什麼作爲具體實例Z？可能有一個簡單的解決方法或一些不太通用的代碼來滿足這種情況。例如，我在想，如果這個工程：

type FinallyBuilder<'z> (finallyAction : 'z -> unit) = 
    member this.Bind<'b> (x : 'z, cont : 'z -> 'b) : 'b = //' 
     try  cont x 
     finally finallyAction x 

看來：

type FinallyBuilder<'z> (finallyAction : 'z -> unit) = 
    member this.Bind<'b> (x : 'z, cont : 'z -> 'b) : 'b = // ' 
     try  cont x 
     finally finallyAction x 
    member this.Zero() =() 

[<AbstractClass>] 
type Animal() = 
    abstract Speak : unit -> unit 

let cleanup = FinallyBuilder (fun (a:Animal) -> a.Speak()) 

type Dog() = 
    inherit Animal() 
    override this.Speak() = printfn "woof" 

type Cat() = 
    inherit Animal() 
    override this.Speak() = printfn "meow" 

cleanup { 
    let! d = new Dog() 
    let! c = new Cat() 
    printfn "done" 
} 
// prints done meow woof 

哦，我明白了，但d和c現在有型Animal。嗯，讓我看看有沒有在我剩餘的聰明......

顯然，你可以做

type FinallyBuilder<'z> (finallyAction : 'z -> unit) = 
    member this.Bind<'a,'b> (x : 'a, cont : 'a -> 'b) : 'b = // ' 
     try  cont x 
     finally finallyAction (x |> box |> unbox) 
    member this.Zero() =() 

它扔掉類型安全（在運行時將拋出一個轉換異常，如果事情是不是最終可行的）。

也可以使特定類型的建設者：

type FinallyBuilderAnimal (finallyAction : Animal -> unit) = 
    member this.Bind<'a,'b when 'a:>Animal>(x : 'a, cont : 'a -> 'b) : 'b = //' 
     try  cont x 
     finally finallyAction x 
    member this.Zero() =() 

let cleanup = FinallyBuilderAnimal (fun a -> a.Speak()) 

但我覺得我出其他的巧妙構思。