Question

在我的Scala应用程序中，我有一个调用函数的函数，该函数返回Future [T]类型的结果。我需要在递归函数调用中传递映射结果。我希望这是尾递归，但地图（或flatMap）打破了这样做的能力。我收到错误“递归调用不在尾部位置。”

以下是此方案的一个简单示例。如何修改这个调用以使调用是尾递归的（不用Await.result（）来破坏Futures的好处）？

import scala.annotation.tailrec
import scala.concurrent.{Await, Future}
import scala.concurrent.duration._

implicit val ec = scala.concurrent.ExecutionContext.global

object FactorialCalc {
  def factorial(n: Int): Future[Int] = {

    @tailrec
    def factorialAcc(acc: Int, n: Int): Future[Int] = {
      if (n <= 1) {
        Future.successful(acc)

      } else {
        val fNum = getFutureNumber(n)
        fNum.flatMap(num => factorialAcc(num * acc, num - 1))
      }
    }

    factorialAcc(1, n)
  }

  protected def getFutureNumber(n: Int) : Future[Int] = Future.successful(n)
}

Await.result(FactorialCalc.factorial(4), 5.seconds)

Answer 1

我可能会弄错，但在这种情况下你的函数不需要是尾递归的。

尾部递归有助于我们在使用递归函数时不使用堆栈。但是，在您的情况下，我们实际上并没有像典型的递归函数那样使用堆栈。

这是因为“递归”调用将在执行上下文的某个线程上异步发生。因此，这种递归调用很可能甚至不会与第一次调用驻留在同一堆栈中。

factorialAcc方法将创建未来对象，最终将异步触发“递归”调用。之后，它会立即从堆栈中弹出。

所以这实际上不是堆栈递归，并且堆栈不会与n成比例增长，它大致保持不变的大小。

您可以通过在factorialAcc方法中的某个位置抛出异常并检查堆栈跟踪来轻松检查这一点。

我重写了你的程序以获得更易读的堆栈跟踪：

object Main extends App {
  import scala.concurrent.{Await, Future}
  import scala.concurrent.duration._

  implicit val ec = scala.concurrent.ExecutionContext.global

  def factorialAcc(acc: Int, n: Int): Future[Int] = {

    if (n == 97)
      throw new Exception("n is 97")

    if (n <= 1) {
      Future.successful(acc)

    } else {
      val fNum = getFutureNumber(n)
      fNum.flatMap(num => factorialAcc(num * acc, num - 1))
    }
  }


  def factorial(n: Int): Future[Int] = {
      factorialAcc(1, n)
  }

  protected def getFutureNumber(n: Int) : Future[Int] = Future.successful(n)

  val r = Await.result(factorial(100), 5.seconds)
  println(r)

}

输出是：

Exception in thread "main" java.lang.Exception: n is 97
at test.Main$.factorialAcc(Main.scala:16)
at test.Main$$anonfun$factorialAcc$1.apply(Main.scala:23)
at test.Main$$anonfun$factorialAcc$1.apply(Main.scala:23)
at scala.concurrent.Future$$anonfun$flatMap$1.apply(Future.scala:278)
at scala.concurrent.Future$$anonfun$flatMap$1.apply(Future.scala:274)
at scala.concurrent.impl.CallbackRunnable.run(Promise.scala:29)
at scala.concurrent.impl.ExecutionContextImpl$$anon$3.exec(ExecutionContextImpl.scala:107)
at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:262)
at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:975)
at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1478)
at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:104)

所以你可以看到堆栈实际上很短。如果这是堆栈递归，你应该看到大约97次调用factorialAcc方法。相反，你只看到一个。

Answer 2

如何使用foldLeft代替？

def factorial(n: Int): Future[Int] = future {
  (1 to n).foldLeft(1) { _ * _ }
}

Answer 3

这是一个foldLeft解决方案，它调用另一个返回未来的函数。

def factorial(n: Int): Future[Int] =
  (1 to n).foldLeft(Future.successful(1)) {
    (f, n) => f.flatMap(a => getFutureNumber(n).map(b => a * b))
  }

def getFutureNumber(n: Int) : Future[Int] = Future.successful(n)

Answer 4

让factorialAcc返回一个Int，并且只在以后的factorial函数中包装它。

def factorial(n: Int): Future[Int] = {

    @tailrec
    def factorialAcc(acc: Int, n: Int): Int = {
      if (n <= 1) {
        acc
      } else {
        factorialAcc(n*acc,n-1)
      }
    }

    future {
      factorialAcc(1, n)
    }
}

应该可以工作。

如何使函数涉及期货尾递归？

4 个答案: