Workaround Scala's questionable Contravariant Implicit resolution rules

contra-variant-implicit-resolution.scala

trait Inv[A] { self: Contra[A] => } 
trait Contra[-A] extends Inv[A @uncheckedVariance]

implicit val C1: Contra[Any] = new Contra[Any] {}
implicit val C2: Contra[Int] = new Contra[Int] {}

assert(implicitly[Inv[Any]] eq C1)                                                                                                                                        
assert(implicitly[Contra[Any]] eq C1)

assert(implicitly[Inv[Int]] eq C2)
assert(implicitly[Contra[Int]] eq C1)

specific.scala

import annotation.unchecked.uncheckedVariance

trait Inv[A] { self: Contra[A @uncheckedVariance] => }
trait Cov[+A] { self: Contra[A @uncheckedVariance] => val selff = self }
trait Contra[-A] extends Cov[A @uncheckedVariance] with Inv[A @uncheckedVariance]

case class Specific[A](a: Contra[A]) {

}

trait SpecificLow {
  implicit def Contra[A](implicit ca: Contra[A]): Specific[A] = Specific(ca)
}

object Specific extends SpecificLow {
  implicit def Cov[A](implicit ca: Cov[A]): Specific[A] = Specific(ca.selff)
}

implicit val CAny: Contra[Any] = new Contra[Any] {
  override def toString = "Contra[Any]"
}
implicit val CInt: Contra[Int] = new Contra[Int] {
  override def toString = "Contra[Int]"
}

assert(implicitly[Inv[Any]] eq CAny)
assert(implicitly[Contra[Any]] eq CAny)
assert(implicitly[Cov[Any]] eq CAny)

assert(implicitly[Inv[Int]] eq CInt)
assert(implicitly[Cov[Int]] eq CInt)
assert(implicitly[Contra[Int]] eq CAny)

assert(implicitly[Contra[String]] eq CAny)
assert(implicitly[Contra[_ >: String]] eq CAny)
assert(implicitly[Cov[_ >: String]] eq CAny)
assert(implicitly[Cov[_ >: Int]] eq CAny)

assert(implicitly[Specific[Any]].a eq CAny)
assert(implicitly[Specific[Int]].a eq CInt)
assert(implicitly[Specific[String]].a eq CAny)