Scala Streams：如何避免保持对头部(和其他元素)的引用

让我们将代码示例简化为极限：

class Test {
  private[this] var next: Test = _

  final def fold(): Int = {
    next = new Test
    next.fold()
  }
}

请注意,您的循环方法也是某个对象的方法.

该方法是最终的(就像Stream#foldLeft一样) – 这非常重要.

使用scalac -Xprint：尾递归优化之后的所有test.scala你将得到：

final def fold(): Int = {
  <synthetic> val _$this: Test = Test.this;
  _fold(_$this: Test){
    ({
      Test.this.next = new Test();
      _fold(Test.this.next)
    }: Int)
  }
};

此代码不会帮助您了解正在发生的事情.

通向神奇理解之地的唯一途径是java字节码.

但你应该记住一件事：没有对象的方法.所有方法都是“静态的”.这只是该方法的第一个参数.如果方法是虚拟的,那就是vtable,但我们的方法是最终的,所以在这种情况下不会有动态调度.

还要注意,没有参数这样的东西：所有参数都只是变量,在方法执行之前初始化.

所以这只是方法的第一个变量(索引0).

我们来看看字节码(javap -c Test.class)：

public final int fold();
  Code:
     0: aload_0       
     1: new           #2                  // class Test
     4: dup           
     5: invokespecial #16                 // Method "<init>":()V
     8: putfield      #18                 // Field next:LTest;
    11: aload_0       
    12: getfield      #18                 // Field next:LTest;
    15: astore_0      
    16: goto          0

让我们用伪scala代码编写这个方法：

static foo(var this: Test): Int {
  :start // label for goto jump

  // place variable `this` onto the stack:
  //   0: aload_0       

  // create new `Test`
  //   1: new           #2                  // class Test
  // invoke `Test` constructor
  //   4: dup           
  //   5: invokespecial #16                 // Method "<init>":()V

  // assign `this.next` field value
  //   8: putfield      #18                 // Field next:LTest;

  this.next = new Test

  // place `this.next` onto the stack
  //  11: aload_0       
  //  12: getfield      #18                 // Field next:LTest;

  // assign `this.next` to variable `this`!
  //  15: astore_0      
  this = this.next // we have no reference to the previous `this`!

  //  16: goto          0
  goto :start
}

在this = this.next之后,我们没有在堆栈或第一个变量中引用前一个.以前这可以通过GC删除！

所以Stream#foldLeft中的tail.foldLeft(…)将替换为this = this.tail,…;转到：开始.因为在foldLeft声明之前,这只是方法@tailrec的第一个参数.

现在我们终于可以理解scalac -Xprint：所有test.scala结果：

final def method(a: A,b: B,...): Res = {
  <synthetic> val _$this: ThisType = ThisType.this;
  _method(_$this: Test,a: A,...){
    ({
      // body
      _method(nextThis,nextA,nextB,...)
    }: Res)
  }
};

手段：

final def method(var this: ThisType,var a: A,var b: B,...): Res = {
  // _method(_$this: Test,...){
  :start

  // body

  //   _method(nextThis,...)
  this = nextThis
  a = nextA
  b = nextB
  ...
  goto :start
};

这正是你在scalac -Xprint之后得到的：所有你的循环方法,但身体将是巨大的.所以在你的情况下：

...
case Some(x) =>
  this = this
  s = s.tail
  acc = accumulate(x,acc)
  goto :start
...

在s = s.tail之后,你没有引用流的头部.