avoid member overloads

It would be nice to avoid overloads. While working on http://blog.ctaggart.com/2017/11/how-to-create-http2-app-in-f.html, it was a major pain to get the F# compiler to use the correct unique overload, especially with optional parameters and base classes that have identical signatures.

That is from server.listen 8843..

I had issues withe end as well:

  type [<AllowNullLiteral>] ServerHttp2Stream =
        inherit Http2Stream

    type [<AllowNullLiteral>] Http2Stream =
        inherit stream.Duplex

        abstract ``end``: unit -> unit
        abstract ``end``: chunk: obj * ?cb: Function -> unit
        abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit

    type [<AllowNullLiteral>] stream.Writable =
        abstract ``end``: unit -> unit
        abstract ``end``: chunk: obj * ?cb: Function -> unit
        abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit

[jgrund]

As a counterpoint to this issue, I think method overloads are doable if we avoid obj type and had return types that were tied to specific options. See here for more info

[alfonsogarciacaro]

Yes, overloads are complicated in F#, that was one of the reasons to create the erased unions instead of automatically generating overloads.

I cannot think of a solution now. If adding a suffix I would like something more meaningful than just the number of parameters, but I know this is hard to with an automatic processor. @jgrund is right in that filling some objs would help the compiler. I’ve also seen sometimes that removing optional arguments solves the ambiguity (see this commit), maybe we could try to implement an algorithm to see when can this be done.