我的 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 .引用:

First, look at

f: => Boolean

Although this is called a "by-name parameter", it is actually implemented as a Function0,

f: () => Boolean

just with different syntax used on both ends.

现在我对 this answer 更加困惑了其中明确指出两者不同。

问题:

• Scala 如何区分 bar来自 baz ？两者的方法签名(不是实现)在反编译代码中是相同的。
• 两种情况下的差异是否不会保留到编译后的字节码中？
• 反编译代码不准确？
• 在编辑 1 之后添加:我发现 scalac 语法树确实显示出差异，bar具有 _root_.scala.<byname>[Int] 类型的第二个参数.它有什么作用？任何解释，指针在scala source或等效的伪代码会有所帮助。
• 请参阅上面的编辑 2:引用的 block 是否正确？如，是 => T Function0 的特殊子类？

最佳答案

How is Scala distinguishing bar from baz? The method signatures (not implementation) for both are identical in the decompiled code.

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 的过程中发生了一些事情。 .

Does the difference in the two scenarios not get persisted into the compiled bytecode?

在 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 .

Is the decompiled code inaccurate

不，它绝对准确。

I found that the scalac syntax tree does show a difference, bar has the second argument of type root.scala.[Int]. What does it do?

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

关于java - Scala如何区分()=>T和=>T，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40251514/