Scala 执行折叠以便于理解

在Scala中，如何将

折叠实现为理解
？我明白了唯一的方法就是使用一些递归调用？这是一次失败的尝试，不知道如何做到这一点？将
折叠
作为理解
的最佳方式是什么

  val nums = List(1,2,3)                         
  nums.fold(0)(_+_)                              
  def recFold(acc: Int = 0): Int = {
    (for {
        a <- nums
        b = recFold(a + acc)
    } yield b).head
  }                                               
    recFold(0) //Stack overflow

val nums=List（1,2,3）
整数倍（0）（u+u）
def重新折叠（acc:Int=0）：Int={
（用于{
折叠可以从右到左或从左到右两种方式实现。对于
加上递归，不需要使用
。递归就足够了

  def foldRight[A, B](as: List[A], z: B)(f: (A, B) => B): B = {
    as match {
      case Nil => z
      case x :: xs => f(x, foldRight(xs, z)(f))
    }
  }

  @annotation.tailrec
  def foldLeft[A, B](as: List[A], z: B)(f: (A, B) => B): B = {
    as match {
      case Nil => z
      case x :: xs => foldLeft(xs, f(x, z))(f)
    }
  }

如果您真的想对
使用
，则不需要递归，但需要一个可变变量：

val nums = List(1,2,3)

def recFold(zero: Int)(op: (Int, Int) => Int): Int = {
  var result: Int = zero
  for { a <- nums } result = op(result, a)
  result
}

recFold(0)(_ + _) // 6

我对scala不是很有经验，但我看不到递归调用返回的基本情况？使用
head
是一个很好的方法，我只是想知道在FP中是否有一些超智能的方法可以像往常一样使用for。。。
def foldLeft[B](z: B)(op: (B, A) => B): B = {
  var result = z
  this foreach (x => result = op(result, x))
  result
}