Calling the base class method from Code Quotations

Question

Let's say I have two simple classes :

type BaseClass() =
    abstract member PreStart : unit -> unit
    default x.PreStart() =
        printfn "Base class PreStart method"

type DerivedClass() as this =
    inherit BaseClass()

    override this.PreStart() =
        // I want to pass the body from outside
        ()

What I'm trying to do is to allow the scenario when one could pass an implementation body of the DerivedClass.PreStart method from outside. Of course I could pass just a function that could be called inside the PreStart method but this has some drawback related to the call of base.PreStart() method. I would have to pass an extra parameter to indicate whatever I want to execute the base method before the overriden body or after if at all.

What I would like to do is to allow the definition of the body like that :

let preStart = (fun (baseFn : unit->unit) ->
                        baseFn() // base class call before the overriden body
                        printfn "PreStart overriden"
                        baseFn() // base class call after the overriden body)

where baseFn() is a call to the base class method. This would be simple if we could pass around the delegate to base.PreStart call but this is not allowed by the compiler for obvious reasons.

My naive implementation with Quotations is as follows :

open FSharp.Quotations
open Microsoft.FSharp.Linq
open Microsoft.FSharp.Linq.QuotationEvaluation
open System.Linq.Expressions

type BaseClass() =

    abstract member PreStart : unit -> unit

    default x.PreStart() =
        printfn "Base class PreStart method"

type DerivedClass(expression : Expr<(unit -> obj) -> obj>) as this =
    inherit BaseClass()

    // this is not optimal <@@ this :> BaseClass @@> doesn't work
    let baseClinst = new BaseClass()
    let bexpr = <@@ baseClinst @@>
    let overrideExpr = expression
    let baseTy = typeof<BaseClass>
    let mthd = baseTy.GetMethod("PreStart")

    override this.PreStart() =
        let baseMthd = Expr.Call(bexpr, mthd, [])
        let combined = <@ ((%overrideExpr) (baseMthd.CompileUntyped())) @>
        let l = QuotationEvaluator.EvaluateUntyped combined
        ()

let preStart = <@ 
                    fun (baseFn : unit->obj) ->
                        baseFn() // base class call before the overriden body
                        printfn "PreStart overriden"
                        baseFn() // base class call after the overriden body
               @>

let d = new DerivedClass(preStart)

if prints the following output as expected:

> d.PreStart();;
Base class PreStart method
PreStart overriden
Base class PreStart method
val it : unit = ()
> 

However I'm not happy with this code

• In the DerivedClass I have to create an instance of the base class let baseClinst = new BaseClass() which servs as a base expression parameter to Expr.Call. Doing this doesn't work let bexpr = <@@ this :> BaseClass @@>. This is just calling another's instance of base class retrieved by reflection.
• I had to modify the type of the function from unit -> unit to unit -> obj because of the return of the call to baseMthd.CompileUntyped()
• It certainly not optimal and ugly.

My question is simple. How to improve this code to be more idiomatic F#? Or maybe there are other means than Quotations to achieve it?

Answer 1

You don't really need quotations for this. The obvious solution (that does not work) is to take a function and pass it base.PreStart as a parameter (so that the function can decide when to call the base class implementation):

type DerivedClass1(preStart) =
    inherit BaseClass()
    override this.PreStart() =
        preStart base.PreStart

Now, this does not work because F# only allows you to call base.PreStart directly and it does not allow passing it as a function. However, you can define a private member that calls the base class implementation and pass this new member as a parameter to prestart:

type DerivedClass(preStart) =
    inherit BaseClass()
    member private this.BasePreStart() = 
        base.PreStart()
    override this.PreStart() =
        preStart this.BasePreStart