Scala 中的隐式函数。这是如何工作的？

Question

我正在关注 Scala 中的教程，我看到了这一点：

object implicitFunctions extends App {
    println("Step 1: How to create a wrapper String class which will extend the String type")
    class DonutString(s: String) {
        def isFavoriteDonut: Boolean = s == "Glazed Donut"
    }

    println("\nStep 2: How to create an implicit function to convert a String to the wrapper String class")
    object DonutConversions {
        implicit def stringToDonutString(s: String) = new DonutString(s)
    }

    println("\nStep 3: How to import the String conversion so that it is in scope")
    import DonutConversions._

    println("\nStep 4: How to create String values")
    val glazedDonut = "Glazed Donut"
    val vanillaDonut = "Vanilla Donut"

    println("\nStep 5: How to access the custom String function called isFavaoriteDonut")
    println(s"Is Glazed Donut my favorite Donut = ${glazedDonut.isFavoriteDonut}")
    println(s"Is Vanilla Donut my favorite Donut = ${vanillaDonut.isFavoriteDonut}")
}

究竟发生了什么？我想没有方法在发现String类，所以我们看一下进口implicits，并从转换String通过调用stringToDonutString通过调用函数并传入缺少方法（串）的接受者。那正确吗？

为什么隐式必须包装在一个对象中？

Answer 1

 ${glazedDonut.isFavoriteDonut}"

当上面被调用时，编译器isFavoriteDonut在 String 中搜索方法（因为glazedDonut是 String 类型）。当然，它没有找到它。

因此，编译器然后搜索一个隐式，它可以转换String为其他类型（让我们称之为Unknown），以便该Unknown类型包含isFavoriteDonut方法。

它在作用域中找到了这样一个隐式函数，它可以转换String => DonutString并且它知道DonutString包含glazedDonut

为什么隐式必须包装在一个对象中？

该规范不允许创建顶级implicit类和函数。https://scala-lang.org/files/archive/spec/2.12/07-implicits.html

隐式修饰符对于所有类型成员以及顶级对象都是非法的。