I am in the process of creating a project that will link up a bunch of similar classes to one common user interface. Effectively, the user will be able to do a similar thing, but choose which method he/she uses, and the methods may have different input parameters, etc. I realize this has been done a million times before, but want to get thoughts on the best way to do this in f#

Here's an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

open System
open System.Reflection
 
type OpEnum =
    | Add = 1
    | Multiply = 2
 
type ITest =
    abstract FuncFromEnum : double -> OpEnum -> double           
 
[<AbstractClass>]
type BaseTest() =
    abstract Add : double -> double
    abstract Multiply : double -> double
    interface ITest with
        member t.FuncFromEnum (b:double) (e:OpEnum) =
            let nm = e.ToString()
            t.GetType().InvokeMember(nm, BindingFlags.InvokeMethod, null, t, [|(box b)|])
            |> unbox<double>
 
type TestOne(x:double) =
    inherit BaseTest()
    default t.Add b = x + b
    default t.Multiply b = x * b

Then one can do something like the following:

1
2
3
4
5
6
7

let fromText (s:string) (t:ITest) =
    let temp = OpEnum.Add
    let op = Enum.Parse(temp.GetType(),s) |> unbox<OpEnum>
    (fun x -> t.FuncFromEnum x op)

let t = TestOne(5.0)
5.0 |> fromText "Add" t

This is the desired functionality. That is, every derived class from BaseTest will have some subset of OpEnum, and the method will have the same name as the OpEnum. That way, desired calculation can be done dynamically by simply returning the desired OpEnum from another function or user input. Further, this can be done for any derived class of BaseTest, and rather than having to create a lookup routine in BaseTest, I reflect on the Enum name to get the right method.

If anyone has experience with this sort of functionality, I would love to know if I am headed in the right direction here. Main questions are:

1) Do I need the interface type here - do I gain anything, or should I start with the base class as an abstract class where I can write the underlying generic functions?

2) Is there another way to pass an enum and call a generic method or is this implementation seem ok?

3) Are there any performance issues with using the System.Type.InvokeMember() function? Will boxing and unboxing slow down the program? (speed will be mildly important here). I could alternatively just use a dictionary to hash the members to the Enum, but I thought that was less elegant.

Thanks very much!