Addressing interface conflicts in F#

Question

I would like to implement the solution described here in F#: Inheritance from multiple interfaces with the same method name

Specifically, in F#, how do I address implementing interface functions that share the same name between two interfaces?

Here is the C# solution:

public interface ITest {
    void Test();
}
public interface ITest2 {
    void Test();
}
public class Dual : ITest, ITest2
{
    void ITest.Test() {
        Console.WriteLine("ITest.Test");
    }
    void ITest2.Test() {
        Console.WriteLine("ITest2.Test");
    }
}

TheQuickBrownFox · Accepted Answer · 2017-07-13T22:33:26.623

In F#, interfaces are always implemented explicitly so this isn't even a problem that needs to be solved. This is how you would implement these interfaces whether or not the method names were the same:

type ITest =
    abstract member Test : unit -> unit

type ITest2 =
    abstract member Test : unit -> unit

type Dual() =
    interface ITest with
        member __.Test() = Console.WriteLine("ITest.Test")

    interface ITest2 with
        member __.Test() = Console.WriteLine("ITest2.Test")

This makes sense when you consider that access of interface methods in F# is also explicit. If you have a Dual you can't call the the Test method. You must first upcast to either ITest or ITest2:

let func (d:Dual) = d.Test() // Compile error!

let func (d:Dual) =
    (d :> ITest).Test()
    (d :> ITest2).Test()
    // This is fine

Note that there is a safe upcast operator :> for casting up the object hierarchy in a way that is guaranteed to work at compile time, and cannot result in a run-time exception.

Sometimes this explicit method access is inconvenient, but I believe it leads to a simplification of the type system that makes more type inference possible and increases convenience and safety overall.

Thanks for the response. It made me realize that my problem is more nuanced because I have a type that inherits from a single abstract interface A, but A implements two abstract interfaces, B and C, both sharing a common method name. In any case, your solution seems to work for that situation as well, by explicitly implementing the underlying interfaces in my type definition. — Robert Sim, Jul 14 '17 at 15:58

Addressing interface conflicts in F#

1 Answers1