使用F＃在类/接口中动态定义几个成员

Question

I'm working on small program using F# just for the personal training and got some moment, which I can't solve.

I'm describing some interface:

type IСalculations =
    abstract member Add : int * int -> int
    abstract member Subtract : int * int -> int
    abstract member Multiply : int * int -> int
    abstract member Divide : int * int -> int

As you can see, the member signature besides the name is the same.

Am I able to do using F# the next (now will be pseudo-code ):

let names = [ "Add", "Subtract", "Multiply", "Divide" ];
let ICalculations = new interface;

foreach ( name in names ) {
    ICalculations[ name ] : int * int -> int
}

The aim is NOT to repeat for each member the signature int * int -> int

Is it possible?

Answer 1

You cannot define interface method types after the interface declaration. But you can define for example Dictionary, containing functions of your type:

open System.Collections.Generic    
type Ops = Add | Subtract | Multiply | Divide
let pseudoInterface = Dictionary<Ops, int * int -> int>()

// Then somewhere in your program you could define this "methods"
pseudoInterface.[Add] <- fun (i, j) -> i + j
pseudoInterface.[Subtract] <- fun (i, j) -> i - j // etc...

Or you can define type alias for function type for brevity:

type Op = int * int -> int
type IСalculations =
    abstract member Add : Op    
    abstract member Subtract : Op
    abstract member Multiply : Op
    abstract member Divide : Op

Answer 2

The only syntax for declaring an interface is :

// Interface declaration:
[ attributes ]
type interface-name =
   [ interface ]     [ inherit base-interface-name ...]
     abstract member1 : [ argument-types1 -> ] return-type1
     abstract member2 : [ argument-types2 -> ] return-type2
     ...
   [ end ]

In the second line of your pseudo-code :

let ICalculations = new interface;

you wish to use a let binding or equivalent. Unfortunately, let bindings only associate an identifier with a value or a function and not with a type or an interface. So I am afraid there is no way. Other functional languages than F#, such as Idris, can do it. If you are only bothered by the verbosity of having to repeat int*int->int, you can define a type alias like so :

module T =
  type Op = int * int -> int

type IСalculations =
    abstract member Add : T.Op
    abstract member Subtract : T.Op
    abstract member Multiply : T.Op
    abstract member Divide : T.Op