Scala 如何区分 () => T 和 => T

Question

我的other question 因重复而被关闭，所以我会再试一次。我也读过this question，我问的是不同的。我有兴趣了解Call-by-Name: => Type 与() => Type 的不同之处的内部实现。

我的困惑来自于查看 javap 和 cfr 反汇编，这两种情况没有区别。

例如ParamTest.scala：

object ParamTest {
  def bar(x: Int, y: => Int) : Int = if (x > 0) y else 10
  def baz(x: Int, f: () => Int) : Int = if (x > 0) f() else 20
}

javap 输出 javap ParamTest.scala:

public final class ParamTest {
  public static int baz(int, scala.Function0<java.lang.Object>);
  public static int bar(int, scala.Function0<java.lang.Object>);
}

CFR 反编译输出 java -jar cfr_0_118.jar ParamTest$.class:

import scala.Function0;

public final class ParamTest$ {
    public static final ParamTest$ MODULE$;

    public static {
        new ParamTest$();
    }

    public int bar(int x, Function0<Object> y) {
        return x > 0 ? y.apply$mcI$sp() : 10;
    }

    public int baz(int x, Function0<Object> f) {
        return x > 0 ? f.apply$mcI$sp() : 20;
    }

    private ParamTest$() {
        MODULE$ = this;
    }
}

编辑 1： Scala 语法树：scalac -Xprint:parse ParamTest.scala

package <empty> {
  object ParamTest extends scala.AnyRef {
    def <init>() = {
      super.<init>();
      ()
    };
    def bar(x: Int, y: _root_.scala.<byname>[Int]): Int = if (x.$greater(0))
      y
    else
      10;
    def baz(x: Int, f: _root_.scala.Function0[Int]): Int = if (x.$greater(0))
      f()
    else
      20
  }
}

编辑 2：邮件列表研究：

在邮件列表中阅读此interesting post，它基本上声明=> T 实现为() => T。引用：

首先，看看

f: => Boolean

虽然这被称为“按名称参数”，但实际上是作为Function0实现的，

f: () => Boolean

只是两端使用不同的语法。

现在我对this answer 更加困惑，它明确指出两者是不同的。

问题：

• Scala 如何区分bar 和baz？两者的方法签名（不是实现）在反编译代码中是相同的。
• 两种方案的差异不会被持久化到编译后的字节码中吗？
• 反编译的代码是否不准确？
• 在编辑 1 之后添加：我发现 scalac 语法树确实有所不同，bar 具有_root_.scala.<byname>[Int] 类型的第二个参数。它有什么作用？任何解释、scala source 中的指针或等效的伪代码都会有所帮助。
• 参见上面的编辑 2：引用的块是否正确？例如，=> T 是 Function0 的特殊子类吗？

Answer 1

Scala 如何区分bar 和baz？方法签名（不是 实现）在反编译代码中是相同的。

Scala 不需要区分两者。从它的角度来看，这是两种不同的方法。有趣的是（至少对我而言），如果我们将 baz 重命名为 bar 并尝试使用“按名称调用”参数创建重载，我们会得到：

Error:(12, 7) double definition:
method bar:(x: Int, f: () => Int)Int and
method bar:(x: Int, y: => Int)Int at line 10
have same type after erasure: (x: Int, f: Function0)Int
  def bar(x: Int, f: () => Int): Int = if (x > 0) f() else 20

这对我们来说是一个暗示，在幕后，Function0 的翻译正在发生一些事情。

这两种情况的差异不会持续到 编译字节码？

在 Scala 发出 JVM 字节码之前，它有额外的编译阶段。在这种情况下，一个有趣的事情是查看“uncurry”阶段（-Xprint:uncurry）：

[[syntax trees at end of uncurry]] 
package testing {
  object ParamTest extends Object {
    def <init>(): testing.ParamTest.type = {
      ParamTest.super.<init>();
      ()
    };
    def bar(x: Int, y: () => Int): Int = if (x.>(0))
      y.apply()
    else
      10;
    def baz(x: Int, f: () => Int): Int = if (x.>(0))
      f.apply()
    else
      20
  }
}

甚至在我们发出字节码之前，bar 就被翻译成Function0。

反编译的代码是否不准确

不，绝对准确。

我发现 scalac 语法树确实有区别，bar 有 root.scala.[Int] 类型的第二个参数。它有什么作用 怎么办？

Scala 编译是分阶段完成的，每个阶段的输出都是下一个阶段的输入。除了解析的 AST 之外，Scala 阶段还创建符号，这样如果一个阶段依赖于特定的实现细节，它将使其可用。 <byname> 是一个编译器符号，它表明此方法使用“按名称调用”，因此其中一个阶段可以看到并对其进行处理。

Answer 2

因为 Scala 就是这样工作的。它将 scala 代码编译为 .class 文件并在 JVM 中执行。因此，.class 文件应该有必要和充分的信息。

确实如此。此信息存储在名为@ScalaSignature 的注释中。 javap -v 应该显示它的存在，但它不是人类可读的。

这是必要的，因为 Scala 签名中有很多信息无法在 JVM 字节码中表示：不仅仅是按名称与 Function0 参数，还有访问限定符、参数名称等。

Answer 3

Scala 代码由编译器分析并转换为 jvm 字节码。在 scala 级别上，您有隐式、非常强大的类型系统、按名称参数调用和其他类似的东西。在字节码中，一切都消失了。没有柯里化参数，没有隐式，只有简单的方法。运行时不需要区分() => A 和=> A，它只是执行字节码。所有检查和验证，您得到的错误都来自分析 scala 代码的编译器，而不是字节码。在按名称编译的过程中只是替换为Function0，并且此类参数的所有用法都调用了apply方法，但这在解析阶段不会发生，但稍后，这就是为什么你会看到@987654325 @ 在编译器输出中。尝试查看后面的阶段。