Scala隐式分辨率对AnyVal有何不同？

Question

I am defining implicits in companion objects that get resolved for all types except AnyVals such as Long and Double etc. I am not exactly sure why it is the case? Are there different resolution rules for AnyVals?

class X(val i:Int) {
  def add[T](implicit x:SomeType[T])=println(x)
}
object X {
  implicit def xx = XType
  implicit def ll = LType
  implicit def dd = DType
}

object Console {
  def main(args: Array[String]): Unit = {
    new X(3).add[X] // works fine
    new X(3).add[Long] // error Error:(16, 16) could not find implicit value for parameter x: com.x.SomeType[Long]
    new X(3).add[Double] // error Error:(16, 16) could not find implicit value for parameter x: com.x.SomeType[Double]
  }
}

sealed trait SomeType[T]

case object XType extends SomeType[X]
case object LType extends SomeType[Long]
case object DType extends SomeType[Double]

Answer 1

The compiler doesn't know how to resolve these two implicits within object X :

implicit def ll = LType
implicit def dd = DType

Calling new X(3).add[X] is able to resolve a SomeType[X] because when looking for an implicit SomeType[X] , the compiler will look within the companion object of X (among other places, see Where does Scala look for implicits? ), and it finds it as implicit def xx = XType .

For SomeType[Long] , the compiler can't find the implicit in scope, nor it is available within the companion objects of SomeType or Long , so it fails. SomeType[Double] fails for the same reason.

If you import X._ within Console it will work, because that would bring all of the implicits within scope. If you want to provide default implicit instances of SomeType s for different types, it would be best to place them within the companion of SomeType .

class X(val i:Int) {
  def add[T](implicit x: SomeType[T]) = println(x)
}

sealed trait SomeType[T]

object SomeType {
  implicit case object XType extends SomeType[X]
  implicit case object LType extends SomeType[Long]
  implicit case object DType extends SomeType[Double]
}

The following will always work now, no matter where you call them:

scala> new X(3).add[X]
XType

scala> new X(3).add[Long]
LType

scala> new X(3).add[Double]
DType

In short, it has nothing to do with AnyVal . You could have added a SomeType[String] alongside the others and had the same issue. The difference was that you were treating X specially.