同样，在上述情况下，应该只有一个隐式函数，其类型为double => Int。否则，编译器会感到困惑，无法正确编译。

//this won't compile

implicit def doubleToInt(d: Double) = d.toInt
implicit def doubleToIntSecond(d: Double) = d.toInt
val x: Int = 42.0

同样，在上述情况下，应该只有一个隐式函数，其类型为double => Int。否则，编译器会感到困惑，无法正确编译。

//this won't compile

implicit def doubleToInt(d: Double) = d.toInt
implicit def doubleToIntSecond(d: Double) = d.toInt
val x: Int = 42.0

我和你有同样的问题，我想我应该通过几个非常简单的例子来分享我是如何开始理解它的(注意，它只涵盖了常见的用例)。

在Scala中有两种使用隐式的常见用例。

在变量上使用它 在函数上使用它

例子如下

在变量上使用它。如您所见，如果在最后一个参数列表中使用隐式关键字，那么将使用最接近的变量。

// Here I define a class and initiated an instance of this class
case class Person(val name: String)
val charles: Person = Person("Charles")

// Here I define a function
def greeting(words: String)(implicit person: Person) = person match {
  case Person(name: String) if name != "" => s"$name, $words"
    case _ => "$words"
}

greeting("Good morning") // Charles, Good moring

val charles: Person = Person("")
greeting("Good morning") // Good moring

在函数上使用它。如您所见，如果在函数上使用隐式，则将使用最接近的类型转换方法。

val num = 10 // num: Int (of course)

// Here I define a implicit function
implicit def intToString(num: Int) = s"$num -- I am a String now!"

val num = 10 // num: Int (of course). Nothing happens yet.. Compiler believes you want 10 to be an Int

// Util...
val num: String = 10 // Compiler trust you first, and it thinks you have `implicitly` told it that you had a way to covert the type from Int to String, which the function `intToString` can do!
// So num is now actually "10 -- I am a String now!"
// console will print this -> val num: String = 10 -- I am a String now!

希望这能有所帮助。

scala中一个非常基本的隐式函数示例。

隐式参数:

val value = 10
implicit val multiplier = 3
def multiply(implicit by: Int) = value * by
val result = multiply // implicit parameter wiil be passed here
println(result) // It will print 30 as a result

注意:这里multiplier将隐式传递到函数multiply中。函数调用中缺失的参数将在当前作用域中按类型查找，这意味着如果作用域中没有Int类型的隐式变量，则代码将无法编译。

隐式类型转换:

implicit def convert(a: Double): Int = a.toInt
val res = multiply(2.0) // Type conversions with implicit functions
println(res)  // It will print 20 as a result

注意:当我们调用multiply函数传递一个double值时，编译器将尝试在当前作用域中找到转换隐式函数，它将Int转换为double(作为函数乘接受Int形参)。如果没有隐式转换函数，则编译器将不会编译代码。

警告:含有讽刺的明智!YMMV……

路易吉的回答是完整而正确的。这篇文章只是通过一个示例对它进行了一点扩展，该示例展示了如何光荣地过度使用隐式，因为这种情况在Scala项目中经常发生。实际上，你甚至可以在“最佳实践”指南中找到它。

object HelloWorld {
  case class Text(content: String)
  case class Prefix(text: String)

  implicit def String2Text(content: String)(implicit prefix: Prefix) = {
    Text(prefix.text + " " + content)
  }

  def printText(text: Text): Unit = {
    println(text.content)
  }

  def main(args: Array[String]): Unit = {
    printText("World!")
  }

  // Best to hide this line somewhere below a pile of completely unrelated code.
  // Better yet, import its package from another distant place.
  implicit val prefixLOL = Prefix("Hello")
}

为什么以及何时应该将请求参数标记为隐式:

您将在操作主体中使用的一些方法具有隐式参数列表，例如Form。Scala定义了一个方法:

def bindFromRequest()(implicit request: play.api.mvc.Request[_]): Form[T] = { ... }

你不一定会注意到这一点，因为你只需要调用myForm.bindFromRequest()，你不必显式地提供隐式参数。不，您让编译器在每次遇到需要请求实例的方法调用时寻找要传入的任何有效候选对象。由于您确实有一个可用的请求，您所需要做的就是将其标记为隐式。

您显式地将其标记为可用于隐式使用。

你暗示编译器，它是“OK”使用的请求对象发送的Play框架(我们给了名字“请求”，但可以只使用“r”或“req”)在任何需要的地方，“偷偷地”。

myForm.bindFromRequest()

看到了吗?它不在那里，但它就在那里!

它发生的时候，你不需要在每个需要它的地方手动插入它(但你可以显式地传递它，如果你愿意，不管它是否标记为隐式):

myForm.bindFromRequest()(request)

如果不将其标记为隐式，则必须执行上述操作。你不需要把它标记为隐式。

什么时候应该将请求标记为隐式?只有在使用声明隐式参数列表期望Request实例的方法时才真正需要这样做。但是为了保持简单，您可以养成总是将请求标记为隐式的习惯。这样你就可以写出漂亮简洁的代码。