Scala REPL 中的递归重载语义 - JVM 语言

Question

使用 Scala 的命令行 REPL:

def foo(x: Int): Unit = {}
def foo(x: String): Unit = {println(foo(2))}

给出

error: type mismatch;
found: Int(2)
required: String

看来你不能在 REPL 中定义重载的递归方法。 我认为这是 Scala REPL 中的一个错误并提交了它，但它几乎立即被关闭，并显示“wontfix：考虑到解释器的语义，我看不出有任何方式可以支持它，因为必须编译这两个方法一起。” 他建议将这些方法放在一个封闭的对象中。

有 JVM 语言实现或 Scala 专家可以解释原因吗？ 我可以看到，如果这些方法互相调用，例如，这将是一个问题，但在这种情况下呢？

或者，如果这是一个太大的问题，并且您认为我需要更多先决知识，是否有人有关于语言实现（尤其是 JVM）的书籍或网站的良好链接？ （我知道 John Rose 的博客和《编程语言语用学》一书……仅此而已。:)

Answer 1

如果您复制这两行并同时粘贴，REPL 将接受。

Answer 2

正如extempore的答案所示，有可能过载。 Daniel 关于设计决策的评论是正确的，但我认为不完整且有点误导。 重载并不取缔（因为它们是可能的），但它们并不容易实现。

导致这种情况的设计决策是：

1. 所有先前的定义都必须可用。
2. 仅编译新输入的代码，而不是每次都重新编译输入的所有内容。
3. 必须有可能重新定义定义（正如丹尼尔提到的）。
4. 必须能够定义诸如 val 和 def 之类的成员，而不仅仅是类和对象。

问题是……如何实现所有这些目标？ 我们如何处理您的示例？

def foo(x: Int): Unit = {}
def foo(x: String): Unit = {println(foo(2))}

从第四项开始， val 或 def 只能在 class、trait、内部定义>对象或包对象。 因此，REPL 将定义放在对象内部，如下所示（不是实际表示！）。

package $line1 { // input line
  object $read { // what was read
    object $iw { // definitions
      def foo(x: Int): Unit = {}
    }
    // val res1 would be here somewhere if this was an expression
  }
}

现在，由于 JVM 的工作方式，一旦定义了其中一个对象，就无法扩展它们。 当然，您可以重新编译所有内容，但我们放弃了它。 因此，您需要将其放在不同的位置：

package $line1 { // input line
  object $read { // what was read
    object $iw { // definitions
      def foo(x: String): Unit = { println(foo(2)) }
    }
  }
}

这解释了为什么您的示例不是重载：它们是在两个不同的位置定义的。 如果将它们放在同一行中，它们将全部定义在一起，这将使它们重载，如即席示例所示。

至于其他设计决策，每个新包都会导入以前包的定义和“res”，并且导入可以相互影响，这使得“重新定义”东西成为可能。

Answer 3

% scala28
Welcome to Scala version 2.8.0.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_20).
Type in expressions to have them evaluated.
Type :help for more information.

scala> def foo(x: Int): Unit = () ; def foo(x: String): Unit = { println(foo(2)) } 
foo: (x: String)Unit <and> (x: Int)Unit
foo: (x: String)Unit <and> (x: Int)Unit

scala> foo(5)

scala> foo("abc")
()

Answer 4

该问题是由于解释器通常必须用给定名称替换现有元素，而不是重载它们。 例如，我经常会尝试一些东西，通常会创建一个名为 test 的方法：

def test(x: Int) = x + x

稍后，假设我正在运行一个不同的实验，并且我创建了另一个名为 test 的方法，与第一个方法无关：

def test(ls: List[Int]) = (0 /: ls) { _ + _ }

这并不是一个完全不切实际的场景。 事实上，这正是大多数人使用口译员的方式，通常甚至没有意识到。 如果解释器任意决定将两个版本的 test 保留在范围内，则可能会导致使用 test 时出现令人困惑的语义差异。 例如，我们可能会调用 test，意外地传递了 Int 而不是 List[Int]（这不是最不可能发生的事故） world）：

test(1 :: Nil)  // => 1
test(2)         // => 4  (expecting 2)

随着时间的推移，解释器的根作用域会变得非常混乱，充满了各种版本的方法、字段等。我倾向于让我的解释器一次打开几天，但如果允许这样的重载，我们就会由于事情变得太混乱，被迫经常“冲洗”口译员。

这不是 JVM 或 Scala 编译器的限制，而是经过深思熟虑的设计决策。 正如错误中提到的，如果您位于根范围之外的其他范围内，您仍然可以重载。 对我来说，将测试方法封装在一个类中似乎是最好的解决方案。