Allow implementation of different generic instantiations of the same interface on the same type

[Horusiath]

Consider following example:

open System

[<Interface>] type IHave<'T> = abstract Value: 'T
[<Interface>] type ILogger = abstract Debug: string -> unit
    
module Log =
  let debug (env: #IHave<ILogger>) = Printf.kprintf env.Value.Debug
    
module Random =
  let number (env: #IHave<Random>) = env.Value.Next()

Now, what we want to is to have a function that will specialize our env parameter over different variants of IHave<> interface - .NET allows types to implement the same interface multiple times with different generic type parameters:

let rollAndPrint env =
    let num = Random.number env
    Log.debug env "Rolled %i" num // compile error: "The type `ILogger' does not match the type 'Random'"

Apparently F# compiler interface inference doesn't take generic type parameters into account. Initially I thought I may be able to trick compiler by using interfaces from IHave<T>:

type ILog = interface inherit IHave<ILogger> end
type IRandom = interface inherit IHave<Random> end
    
module Log =
    let debug (env: #ILog) = Printf.kprintf env.Value.Debug
    
module Random =
    let number (env: #IRandom) = env.Value.Next()
    
let rollAndPrint env =
    let num = Random.number env
    Log.debug env "Rolled %i" num

But this also fails with the same exact error. Specifying env type constraints ('e when 'e :> IHave<ILogger> and 'e :> IHave<Random>) explicitly also fails with message: Type constraint missmatch. The type ''e' is not compatible with IHave<Random>.

Implementing different versions of the same interface is permitted in C#, however it's not the case in F#. Example:

type Env() =
    interface IHave<ILogger> with member _.Value = { new ILogger with member _.Debug msg = Console.WriteLine(msg) }
    interface IHave<Random> with member _.Value = Random()

fails with error:

This type implements the same interface at different generic instantiations 'IHave' and 'IHave'. This is not permitted in this version of F#.

This pattern is sometimes used in for message handling of different message types, including cases in popular C# libraries like MediatR. I think it could be useful to add this feature to F# as well.

Affidavit

Please tick this by placing a cross in the box:

• This is not a question (e.g. like one you might ask on stackoverflow) and I have searched stackoverflow for discussions of this issue
• I have searched both open and closed suggestions on this site and believe this is not a duplicate
• [] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:

• This is not a breaking change to the F# language design
• [] I or my company would be willing to help implement...
• ...and/or test this with a help of a mentor.

[cartermp]

Closing as duplicate of #545

There is also a trial implementation here that might be worth contributing a test to, if you're interested: dotnet/fsharp#2867