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

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:邮件列表研究:

阅读邮件列表上的这篇有趣的帖子,该帖子基本上表明了这=> T一点() => T.引用:

首先,看看

f: => Boolean

虽然这被称为"按名称参数",它实际上是作为一个实现Function0,

f: () => Boolean

只是在两端使用不同的语法.

现在我对这个答案更加困惑,这个答案明确指出两者是不同的.

问题:

• 如何区分斯卡拉bar从baz？两者的方法签名(不实现)在反编译代码中是相同的.
• 这两种情况的区别是不是持久存在于编译的字节码中？
• 反编译代码是否不准确？
• 在编辑1之后添加:我发现scalac语法树确实显示了差异,bar具有类型的第二个参数_root_.scala.<byname>[Int].它有什么作用？任何解释,scala源中的指针或等效的伪代码都会有所帮助.
• 请参阅上面的编辑2:引用的块是否正确？如在,是=> T一个特殊的子类Function0？

Answer 1

如何区分斯卡拉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>是一个编译器符号，它表明此方法使用“按名称调用”，以便其中一个阶段可以看到并对其进行处理。