如何从覆盖方法中的计算表达式调用基本 F# 方法？

Question

如何从重写方法中的计算表达式调用基本 F# 方法？

这里是一个令人惊讶的问题的一些人为的例子。不要问我为什么需要 在这种特殊情况下，实际用例更有意义，但它是 难以代表。特别是async是无关紧要的，在实际中 案例我使用不同的计算表达式，甚至不需要爆炸 (!) 用于调用基本方法。但是症状是一样的。

// Base class with a virtual method
type T1 () =
    abstract Test : unit -> Async<unit>
    default _.Test () =
        async {
            printfn "In test"
        }

// Derived class with an overridden method calling the base in a computation expression
type T2 () =
    inherit T1 ()
    override _.Test () =
        async {
            do! base.Test ()
        }

let t2 = T2 ()
t2.Test () |> Async.RunSynchronously

以上代码无法编译：

error FS0405: A protected member is called or 'base' is being used. This is
only allowed in the direct implementation of members since they could
escape their object scope.

这条神秘的信息是什么意思？我正在给一位公众成员打电话 直接实现它，就像编译器“想要”一样。

那么主要的问题是，在这种情况下如何调用基本方法？什么是 惯用的 F# 方式？

解决方法是可能的，例如：

type T1 () =
    abstract Test : unit -> Async<unit>
    default m.Test () =
        m.DoTest ()

    member _.DoTest () =
        async {
            printfn "In test"
        }

type T2 () =
    inherit T1 ()
    override m.Test () =
        async {
            do! m.DoTest ()
        }

let t2 = T2 ()
t2.Test () |> Async.RunSynchronously

我并不是真的在寻找解决方法，但看到其他人会很有趣。

Answer 1

这里的问题是async 中的代码被编译成一个单独的类，然后它存在于当前类之外，因此它不能以典型的方式调用基方法。

在这种情况下，您可以在async 块之前调用该方法。这是可行的，因为这只是普通方法体的一部分。该方法返回async，直到你用do!调用它才真正执行

type T2 () =
    inherit T1 ()
    override __.Test () =
        let baseTest = base.Test ()
        async {
            do! baseTest
        }

这是一个不错但有限的技巧。当您需要首先计算一些参数然后将它们传递给Test 时，它将不起作用（因为您不能将baseTest 设为函数 - 它必须是一个值）。在这种情况下，唯一的选择是定义一个调用基本方法的辅助方法：

type T2 () =
    inherit T1 ()
    member private x.BaseTest() = 
        base.Test ()
    override x.Test () =
        async {
            do! x.BaseTest()
        }

我认为这比您的解决方法要好一些，因为它不需要基类中的任何虚拟方法。 base.Test 调用将从派生类的私有方法中工作。

Answer 2

解决方法是使用自标识符：

type T2 () as self =
    inherit T1 ()
    override _.Test () =
        async {
            do! self.Test ()
        }

我认为这里不允许base 的原因是在创建T1 时，它需要了解T1。因此T1 成为递归定义，F# 默认不支持递归定义。 as self 使 T2 递归定义并允许这样做。