Question

为什么编译器不能翻译Scala

(1,2,3,4,5,6).foldRight(10)(_ * _)

到Java等价物

final int[] intArray = new int[]{1,2,3,4,5,6};
int accumulator = 10;

for(int i = intArray.legth - 1; i >=0; i--) {
  accumulator = intArray[i] * accumulator;
}

问题是：为什么foldLeft和reduceLeft是尾递归的，但是他们的右对手不是？

以下链接表示右手不是尾递归。我在问为什么会这样。

How do you know when to use fold-left and when to use fold-right?

Implications of foldr vs. foldl (or foldl')

http://programming-scala.labs.oreilly.com/ch08.html

Answer 1

这是折叠如何进行的问题。 foldLeft操作安排

Seq(1, 2, 3).foldLeft(10)(_ - _)

作为

(((10 - 1) - 2) - 3)

（即4），而foldRight排列

Seq(1, 2, 3).foldRight(10)(_ - _)

作为

(1 - (2 - (3 - 10)))

（即-8）。

现在，想象一下你是从袋子里拿出数字1,2和3，然后用铅笔在纸上进行计算。

在foldRight案例中你被迫这样做：

从包中取出 n 号
写“ n - ？”在纸上
如果包里还有号码，请从包中取出另一个 n ，否则请转到6.
删除问号并将其替换为“（ n - ？）”
从3开始重复。
删除问号并将其替换为10
执行计算

在foldLeft案例中，您可以这样做：

在纸上写10
如果包里还有数字，请从包中取出另一个 n ，否则请转到5.
在您已有的表达式旁边写上“ - n ”
从2开始重复。
执行计算

但你不会，因为你也可以这样做：

在纸上写10
从包中取出 n 号
从您拥有的值中减去 n ，删除该值并记下新值
从2开始重复。

无论袋子里有多少个数字，你只需要在纸上写下一个值。尾部呼叫消除（TCE）意味着不是在堆栈上构建大型递归调用结构，而是可以随时弹出并替换累积值。（即，递归表达的计算基本上以迭代方式执行。）

正如其他人所说，随机访问结构（例如ArrayLike）允许foldRight重新排列为foldLeft操作，因此符合TCE条件。以上描述适用于无法做到的情况。

Answer 2

(1, 2, 3, 4, 5, 6)是一个6值元组，没有foldRight，但Array(1, 2, 3, 4, 5, 6)没有。

ArrayLike是一个特征子类化索引序列，具有有效的元素访问权限，这意味着它已经优化了某些方法，包括例如foldRight。每个数组都隐式转换为ArrayLike特征的子类。来自Scala主干：

  @tailrec
  private def foldr[B](start: Int, end: Int, z: B, op: (A, B) => B): B =
    if (start == end) z
    else foldr(start, end - 1, op(this(end - 1), z), op)

字节码：

private static java.lang.Object foldr(scala.collection.IndexedSeqOptimized, int, int, java.lang.Object, scala.Function2);

...

  Code:
   Stack=6, Locals=6, Args_size=5
   0:   iload_1
   1:   iload_2
   2:   if_icmpne   7
   5:   aload_3
   6:   areturn
   7:   aload_0
   8:   iload_2
   9:   iconst_1
   10:  isub
   11:  aload   4
   13:  aload_0
   14:  iload_2
   15:  iconst_1
   16:  isub
   17:  invokeinterface #21,  2; //InterfaceMethod scala/collection/SeqLike.apply:(I)Ljava/lang/Object;
   22:  aload_3
   23:  invokeinterface #72,  3; //InterfaceMethod scala/Function2.apply:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
   28:  astore_3
   29:  istore_2
   30:  astore_0
   31:  goto    0
  LineNumberTable: 
   line 68: 0
   line 67: 6
   line 69: 7

编辑：字节码中的方法是迭代的，这意味着编译器必须应用尾调用优化。

如果没有有效的元素访问（即高效的apply方法），最好的方法通常是使用迭代器和非尾递归函数来实现foldRight，或通过构建新的方法来反转集合一个并对其进行foldLeft（后者已完成，目前已完成）。对于具有高效随机访问的所有序列，此行为将被覆盖并优化。

为什么foldRight和reduceRight不是尾递归？

2 个答案: