Contravariant typeclasses and specificity for `Nothing` were not yet good enough for ourselves?

[Blaisorblade]

Apparently, for contravariant typeclasses, an instance for Nothing is ambiguous with instances for List[T] and Option[T]. That blocks instance resolution for something as simple as List().
I'm not sure whether this is an issue with the spec or with the implementation; I suppose this was an oversight. But it's enough to make instance resolution for Show unusable for us, so much that in #4437 people are proposing to drop Show altogether (also for unrelated reasons). Here's the puzzler:

trait Show[-T] { def show(x: T): String; def instName: String }
implicit def showOption[T]: Show[Option[T]] = new Show { def show(x: Option[T]) = "showOption"; def instName = "showOption" } // XXX
scala> implicitly[Show[Nothing]].instName
val res5: String = "showOption"
scala> implicit def showNothing: Show[Nothing] = new Show[Nothing] { def show(x: Nothing) = ""; def instName = "showNothing" }
implicit val showNothing: Show[Nothing]
scala> implicitly[Show[Nothing]].instName
val res6: String = "showNothing"
scala> implicit def showList[T]: Show[List[T]] = new Show { def show(x: List[T]) = "showList"; def instName = "showList" } // XXX
implicit val showList[T] => Show[List[T]]
scala> implicitly[Show[Nothing]].instName
1 |implicitly[Show[Nothing]].instName
  |                         ^
  |ambiguous implicit arguments: both method showList and method showNothing match type Show[Nothing] of parameter ev of method implicitly in object DottyPredef

• also investigate covariant and instances for Any, regardless that it's maybe less of a problem

[Blaisorblade]

/cc @alexknvl @OlivierBlanvillain

[Blaisorblade]

Still same behavior after merging #4329.

[Blaisorblade]

OTOH, either before or after #4329 and with or without showNothing, resolution for List() works now:

scala> implicitly[Show[List[Nothing]]].instName
val res2: String = showList
scala> implicitly[Show[Option[Nothing]]].instName
val res3: String = showOption
scala> def show[T: Show](t: T) = implicitly[Show[T]].show(t)
def show[T](t: T)(implicit evidence$1: Show[T]): String
scala> show(List())
val res4: String = showList
scala> show(None)
val res1: String = showOption
scala> show(Some(1))
val res2: String = showOption
scala> show(Nil)
val res3: String = showList
scala> show(1 :: Nil)
val res4: String = showList

[Blaisorblade]

New plan: ensure all of this is sufficiently tested, and cross-check with Scalac tests.

[OlivierBlanvillain]

So what are we missing here? A spec for the current behavior? I'm not sure where would be the best place to put that, but the comment in isAsSpecificValue seems to be the best documentation we have at the moment.

[Blaisorblade]

I wanted to get back to this, but I'm not sure there is a real problem any more (per #4465 (comment)). In doubt, I should probably close this — feel free to reopen and reassign.