避免使用隐式扩展类型？

Question

试图避免使用隐式 class 扩大特定文字类型：

implicit class keepAsListOfInt(val listOfInt: List[Int]) extends AnyVal {
  def :+(long: Long): List[Int] = listOfInt :+ long.toInt
}

// Won't compile - already widened to List[AnyVal]
val listOfInt: List[Int] = List(1) :+ 2L

但由于编译器已经将表达式 List(1) :+ 2L 扩展为 List[AnyVal]，因此永远不会调用隐式转换。我能以某种方式隐式强制转换吗？

更新 - 感谢 sachav's reply and Alexey 的合理关注，以下代码似乎可以完成这项工作：

import scala.language.implicitConversions

implicit def listAnyValToListInt(l: List[AnyVal]): List[Int] = l.map {
  case n: Int                      => n
  case n: Long if n < Int.MinValue =>
    throw new IllegalArgumentException("Can't cast too small Long to Int: " + n)
  case n: Long if n > Int.MaxValue =>
    throw new IllegalArgumentException("Can't cast too big Long to Int: " + n)
  case n: Long                     => n.toInt
  case v                           =>
    throw new IllegalArgumentException("Invalid value: " + v)
}

val valid: List[Int] = List(1) :+ 2
val invalid: List[Int] = List(1) :+ 30000000000L // fails at runtime

如果有一个编译时的解决方案，那还是很好的。

Answer 1

适用的方法 :+ 在 List class 本身上可用，因此编译器不会费心查找由隐式添加的任何其他具有相同名称的方法。

我认为最好的解决方案可能是 WartRemover, as it happens this case is covered by the built-in AnyVal wart。

Answer 2

一个丑陋的解决方案是接受到 List[AnyVal] 的转换，并添加从 List[AnyVal] 到 List[Int] 的隐式转换：

implicit def listAnyValToListInt(l: List[AnyVal]): List[Int] = l.map {
  case e: Int => e
  case e: Long => e.toInt
}

val listOfInt: List[Int] = List(1) :+ 2L //compiles

虽然一个不受欢迎的副作用是 val listOfInt: List[Int] = List(1) :+ 2.0 之类的表达式会抛出 MatchError。

避免使用隐式扩展类型？

Avoid type widening with implicit?

scala

implicit