Allow method overloading on bound generic types

[erickt]

It'd be nice if we could support method overloading on generic types, but overloading only works on concrete types. I ran into this when I was implementing the new serialization library. Here's a reduced example: https://gist.github.com/3801125. Without generic method overloading, I cannot generically use two different serializers in the same function.

[eholk]

I think this is by design, since it sounds like allowing this would sacrifice coherence.

http://pcwalton.github.com/blog/2012/05/28/coherence/

[nikomatsakis]

I don't think it necessarily violates coherence, but it would violate "no overloading" rules I proposed here:

http://smallcultfollowing.com/babysteps/blog/2012/10/04/refining-traits-slash-impls/

I also describe a workaround.

[nikomatsakis]

Admittedly, a very painful one.

[nikomatsakis]

The thing is that what @erickt is really asking for here is not exactly overloading. Instead, the use of overloaded bounds was kind of a workaround for the inability to say something like "a type T that is serializable by any serializer".

Actually, the best answer (at least at the moment) for this specific scenario is to use a trait type. I don't believe the Serializable interface refers to the self type, therefore one could write:

fn print2<
    S1: Serializer,
    S2: Serializer,
    T: Serializable<@Serializer>
>(t: T, s1: @S1, s2: @S2) {
    t.serialize(s1 as @Serializer);
    io::println("");

    t.serialize(s2 as @Serializer);
    io::println("");
}

Here I've rephrased the example in terms of @ rather than & merely because this is closer to being implemented today. You can could do the same thing with &S1, &S2, and &Serializer once we implement that properly.

In any case, I'm going to close, because I don't expect we'll fix this case.