F #: implementazione di un'interfaccia con membri sovraccaricati

Question

Ho definito un'interfaccia in F # con un metodo sovraccarico. Secondo la richiesta del compilatore, il sovraccarico usa argomenti tupled al posto di quelle al curry:

type IInterface = 
    abstract member Do : (int * string) -> unit 
    abstract member Do : int -> unit 

poi creo una classe che implementa l'interfaccia:

type ImplementingClass = 
    interface IInterface with 
     member this.Do (i, s) =() 
     member this.Do i =() 

Tuttavia, così facendo le rese l'errore del compilatore per la prima di entrambi i metodi: "Questo override prende un diverso numero di argomenti al membro astratto corrispondente"

Cosa sto facendo di sbagliato qui?

Answer 1

C'è una sottile differenza tra i due seguenti:

abstract member Do : int * string -> unit 
abstract member Do : (int * string) -> unit 

Se si aggiungono le parentesi, stai dicendo che il parametro è una tupla e il compilatore dovrebbe produrre un metodo di prendere Tuple<int, string>. Senza parentesi, il metodo verrà compilato in base a due parametri. Il più delle volte, questo è nascosto e puoi ignorarlo, ma purtroppo non sempre.

Quindi, è possibile modificare la definizione dell'interfaccia per utilizzare il metodo "a due parametri" ordinario (questo sarebbe il mio metodo preferito: è ancora possibile chiamare il metodo con tupla come argomento e appare più bello in .NET/C# view):

type IInterface = 
    abstract member Do : int * string -> unit 
    abstract member Do : int -> unit 

type ImplementingClass = 
    interface IInterface with 
     member this.Do (i, s) =() 
     member this.Do i =() 

Oppure si può implementare l'interfaccia così com'è:

type ImplementingClass = 
    interface IInterface with 
     member this.Do((i:int, s:string)) =() 
     member this.Do(i:int) =() 

Purtroppo, questo è un po 'brutto - è necessario le annotazioni di tipo in modo che il compilatore può senza ambiguità decidere quale metodo stai implementando.