Contravariance and Specificity

Jason sums up the contravariance issue with aplomb. Extant ticket #2509 is wontfix, but we hope to change this someday. Kris's comment in #2509 also strikes at the problem.

I attempt to analogize implicit search for a class with a contravariant parameter to method dispatch, as follows.

A method overload:

def f(x: Any, y: Any): Int
def f(x: Dog, y: Dog): Int

We know which of those methods is chosen whenever possible. When one is looking for an implicit value with a contravariant type parameter, the only way to use the value with respect to the contravariant type is by calling methods which accept that type as a parameter:

trait Ordering[-T] { def cmp(x: T, y: T): Int }

If we view the generic version of "cmp" as an overload across all possible Ts, then for any concrete T, the most specific possible method (and I mean the SLS definition of "most specific") is

def cmp(x: T, y: T): Int

And the least is

def cmp(x: Any, y: Any): Int

Now if we choose to view implicit resolution as static overloading resolution taking place with an extra layer of indirection, then the choice between Ordering[Any] and Ordering[Dog] is the same as the choice between

def cmp(x: Dog, y: Dog): Int
def cmp(x: Any, y: Any): Int

Considering the asymmetry with covariance: if covariant then you can't call methods which accept the type as a paramter, you can only call methods which produce it. So now we are resolving this overload: def g(): Any def g(): Dog

OK, scala won't let us write that overload: you can't overload solely on return type. So I don't know what that says. But I'm pretty sure if we could write that overload we'd spec it to prefer Dog.

So can we exploit the basis for overloading resolution in implicit search?

---

Another point from Jason: You could also consider that polymorphic dispatch always chooses a the method implementation deepest in the inheritance hierarchy, regardless of whether the 'MyType' appears in a co-, contra-, or in-variant position in that method signature.

class Animal extends Ordered[Animal] with Clonable[Animal] {
   def compareTo(o: Animal): Int
   def clone: Animal
}
class Dog extends Animal with Ordered[Dog] with Clonable[Dog] {
   def compareTo(o: Dog): Int
   def clone: Dog
}