将scala隐式转换带入范围的问题

Question

我在玩隐式，但我有一些我不理解的行为。

我定义了一个简单的类及其伴生对象（只是为了对隐式进行快速测试）如下

class SimpleNumber(val numb: Int) {
    def sum(n: Int) = numb + n
}

object SimpleNumber {
    implicit def stringToInt(s: String) = s.toInt
}

stringToInt 方法应该在我通过传递一个字符串而不是一个 int 来调用 sum 方法的情况下工作，以便它可以转换为一个 int（它只是为了测试目的，所以我不需要检查错误或异常）。

如果我将上述代码粘贴到 repl (:paste) 中，我会收到此警告

警告：应该启用隐式转换方法 stringToInt 通过使隐式值 scala.language.implicitConversions 可见。 这可以通过添加导入子句“import scala.language.implicitConversions”来实现 或通过设置编译器选项 -language:implicitConversions。

所以我转到 VSCode 并粘贴了相同的代码，以查看是否可以通过金属插件获得更多信息，但该警告甚至没有弹出。然后我创建了一个扩展 App trait 的新对象来测试这样的代码

object TestDriver extends App{
    
    val a = new SimpleNumber(4)
    println(a.sum("5"))
}

但我收到以下错误

类型不匹配；发现：String("5") required: Int

我尝试按照 repl 的建议导入 implicitConversions，首先在伴随对象中，然后在 TestDriver 对象中，但无济于事。然后我直接在 TestDriver 对象中导入了隐式方法，并且成功了。

import SimpleNumber.stringToInt

object TestDriver extends App{
    val a = new SimpleNumber(4)
    println(a.sum("5"))
}

为什么import scala.language.implicitConversions 没有像我想象的那样工作？我正在使用 scala 2.13.3

Answer 1

为什么import scala.language.implicitConversions 没有像我想象的那样工作？

import scala.language.implicitConversions 只是表示隐式转换是在代码中定义的，而不是将特定转换带入范围。你可以这样做

import SimpleNumber._

将stringToInt 带入本地范围。

Where does Scala look for implicits?

那我应该使用方法重载吗？

取决于你的目标。隐式转换（通常不推荐）不仅仅用于方法重载。在您的示例中，String 可以在所有需要 Int 的地方使用（例如，通常标准类型，如 Int、String、Function 不应用于隐式，使用自定义隐式类型）。如果您仅将隐式转换用于方法重载，那么是的，您应该更喜欢后者。不要忘记，方法重载不仅可以作为

class SimpleNumber(val numb: Int) {
  def sum(n: Int):    Int = numb + n
  def sum(n: String): Int = numb + n.toInt
}

但也有type class

class SimpleNumber(val numb: Int) {
  def sum[A: ToInt](n: A): Int = numb + n.toInt
}

trait ToInt[A] {
  def toInt(a: A): Int
}
object ToInt {
  implicit val int: ToInt[Int]    = identity
  implicit val str: ToInt[String] = _.toInt
}

implicit class ToIntOps[A](val a: A) extends AnyVal {
  def toInt(implicit ti: ToInt[A]): Int = ti.toInt(a)
}

或magnet

import scala.language.implicitConversions
import Predef.{augmentString => _, _} // to avoid implicit ambiguity

class SimpleNumber(val numb: Int) {
  def sum(n: ToInt): Int = numb + n.toInt()
}

trait ToInt {
  def toInt(): Int
}
object ToInt {
  implicit def fromInt(i: Int):    ToInt = () => i
  implicit def fromStr(s: String): ToInt = () => s.toInt
}

请注意，您不必导入ToInt。

Overloading methods based on generics

Type erasure problem in method overloading