Scala 隐式转换陷阱

EDIT
好的，@Drexin 提出了一个很好的观点：使用隐式转换器时类型安全性的损失/令人惊讶的结果。

一个不太常见的转换怎么样，不会与 PreDef 隐式发生冲突？例如，我正在 Scala 中使用 JodaTime（很棒的项目！）。在定义隐式的同一控制器包对象中，我有一个类型别名：

type JodaTime = org.joda.time.DateTime

以及将 JodaTime 转换为 Long 的隐式（对于构建在 ScalaQuery 之上的 DAL，其中日期存储为 Long）

implicit def joda2Long(d: JodaTime) = d.getMillis

这里，PreDef 和我的控制器包隐式之间不能存在歧义，并且控制器隐式不会过滤到 DAL，因为它位于不同的包范围中。所以当我这样做时

dao.getHeadlines(articleType, Some(jodaDate))

在我看来，到 Long 的隐式转换是安全地完成的，并且考虑到基于日期的查询被大量使用，我保存了一些样板文件。

类似地，对于 str2Int 转换，控制器层接收 servlet URI 参数作为 String -> String。在很多情况下，URI 会包含数字字符串，因此当我过滤路由以确定 String 是否为 Int 时，我不想每次都 stringVal.toInt ；相反，如果正则表达式通过，则让隐式将字符串值转换为 Int 。总的来说，它看起来像：

implicit def str2Int(s: String) = s.toInt
get( """/([0-9]+)""".r ) {
  show(captures(0)) // captures(0) is String
}
def show(id: Int) = {...}

在上述上下文中，这些隐式转换的有效用例是，还是总是显式的？如果是后者，那么what are有效的隐式转换用例？

ORIGINAL
In a 封装对象我定义了一些隐式转换，其中之一是简单的 String 到 Int：

implicit def str2Int(s: String) = s.toInt

一般来说，这种方法工作得很好，采用 Int 参数但接收 String 的方法会转换为 Int，就像返回类型设置为 Int 但实际返回值是 String 的方法一样。

太好了，现在在某些情况下，编译器会因可怕的模糊隐式错误：

类型为 (x: String) 的对象 Predef 中的两个方法 AugmentString scala.collection.immutable.StringOps 和方法 str2Int(s: String) Int 是否有可能从 java.lang.String 到 ?{val 的转换函数 toInt: ?}

我知道发生这种情况的情况是在尝试进行手动内联字符串到整数转换时。例如，val i = "10".toInt

我的解决方法/黑客方法是创建一个 asInt 帮助程序以及包对象中的隐式内容：def asInt(i: Int) = i并用作，asInt("10")

那么，隐式最佳实践是隐式的（即通过烧伤来学习），还是有一些指导方针可以遵循，以免陷入自己制造的陷阱？换句话说，是否应该避免简单、常见的隐式转换，而只在要转换的类型唯一的情况下使用？ （即永远不会陷入歧义陷阱）

感谢您的反馈，隐式非常棒......当它们按预期工作时;-)

我认为您在这里混合了两种不同的用例。

在第一种情况下，您使用隐式转换来隐藏不同类之间在功能相同的情况下的任意区别（或者对您来说是任意区别）。这JodaTime to Long隐式转换属于该类别；这可能是安全的，而且很可能是个好主意。我可能会使用丰富我的图书馆模式，然后写

class JodaGivesMS(jt: JodaTime) { def ms = jt.getMillis }
implicit def joda_can_give_ms(jt: JodaTime) = new JodaGivesMS(jt)

and use .ms每次通话时，都要明确。原因是单位在这里很重要（毫秒不是微秒不是秒不是毫米，但都可以表示为整数），我宁愿离开some在大多数情况下，记录接口处的单位。getMillis每次打字都有点费劲，但是ms还不错。尽管如此，这种转换还是合理的（如果对未来几年可能修改代码的人（包括您）有充分的记录）。

然而，在第二种情况下，您在一种非常常见的类型和另一种非常常见的类型之间执行不可靠的转换。确实，您仅在有限的上下文中执行此操作，但该转换仍然容易逃脱并导致问题（异常或类型不是您的意思）。相反，您应该编写正确处理转换所需的方便例程，并在任何地方使用它们。例如，假设您有一个字段，您希望该字段为“是”、“否”或整数。你可能有类似的东西

val Rint = """(\d+)""".r
s match {
  case "yes" => println("Joy!")
  case "no" => println("Woe!")
  case Rint(i) => println("The magic number is "+i.toInt)
  case _ => println("I cannot begin to describe how calamitous this is")
}

但是这段代码is wrong， 因为"12414321431243".toInt当您真正想说的是情况是灾难性的时，会抛出异常。相反，您应该编写正确匹配的代码：

case object Rint {
  val Reg = """([-]\d+)""".r
  def unapply(s: String): Option[Int] = s match {
    case Reg(si) =>
      try { Some(si.toInt) }
      catch { case nfe: NumberFormatException => None }
    case _ => None
  }
}

并用这个代替。现在，与其执行危险的操作和隐含的转换自String to Int，当您执行匹配时，所有正则表达式匹配（以避免在错误解析时抛出和捕获大量异常）和异常处理（即使正则表达式通过）都会得到正确处理。

如果您有一个同时具有字符串和 int 表示形式的东西，请创建一个新类，然后对每个类进行隐式转换（如果您不希望使用该对象（您知道可以安全地使用其中之一））继续重复某个方法调用并没有真正提供任何启发。