如何推理 Scala Cats / fs2 中的堆栈安全性？

Question

这是fs2 文档中的一段代码。函数go 是递归的。问题是我们如何知道它是否是堆栈安全的以及如何推断任何函数是否是堆栈安全的？

import fs2._
// import fs2._

def tk[F[_],O](n: Long): Pipe[F,O,O] = {
  def go(s: Stream[F,O], n: Long): Pull[F,O,Unit] = {
    s.pull.uncons.flatMap {
      case Some((hd,tl)) =>
        hd.size match {
          case m if m <= n => Pull.output(hd) >> go(tl, n - m)
          case m => Pull.output(hd.take(n.toInt)) >> Pull.done
        }
      case None => Pull.done
    }
  }
  in => go(in,n).stream
}
// tk: [F[_], O](n: Long)fs2.Pipe[F,O,O]

Stream(1,2,3,4).through(tk(2)).toList
// res33: List[Int] = List(1, 2)

如果我们从另一个方法调用go，它是否也是堆栈安全的？

def tk[F[_],O](n: Long): Pipe[F,O,O] = {
  def go(s: Stream[F,O], n: Long): Pull[F,O,Unit] = {
    s.pull.uncons.flatMap {
      case Some((hd,tl)) =>
        hd.size match {
          case m if m <= n => otherMethod(...)
          case m => Pull.output(hd.take(n.toInt)) >> Pull.done
        }
      case None => Pull.done
    }
  }

  def otherMethod(...) = {
    Pull.output(hd) >> go(tl, n - m)
  }

  in => go(in,n).stream
}

Answer 1

我之前的回答here 提供了一些可能有用的背景信息。基本思想是某些效果类型具有直接支持堆栈安全递归的flatMap 实现——您可以显式或通过递归任意深度嵌套flatMap 调用，并且不会溢出堆栈。

对于某些效果类型，由于效果的语义，flatMap 不可能是堆栈安全的。在其他情况下，可以编写堆栈安全的flatMap，但实施者可能出于性能或其他考虑而决定不这样做。

不幸的是，没有标准（甚至传统）方法可以知道给定类型的 flatMap 是否是堆栈安全的。 Cats 确实包含一个 tailRecM 操作，它应该为任何合法的单子效果类型提供堆栈安全的单子递归，有时查看已知合法的 tailRecM 实现可以提供一些关于 flatMap 是否是堆栈的提示 -安全的。对于Pull，它看起来像this：

def tailRecM[A, B](a: A)(f: A => Pull[F, O, Either[A, B]]) =
  f(a).flatMap {
    case Left(a)  => tailRecM(a)(f)
    case Right(b) => Pull.pure(b)
  }

这个tailRecM 只是通过flatMap 递归，我们知道Pull 的Monad 实例is lawful，这很好地证明Pull 的flatMap 是堆栈安全的.这里的一个复杂因素是Pull 的实例对F 有一个ApplicativeError 约束，而Pull 的flatMap 没有，但在这种情况下不会改变任何东西。

所以这里的tk 实现是堆栈安全的，因为Pull 上的flatMap 是堆栈安全的，我们通过查看它的tailRecM 实现知道这一点。 （如果我们再深入一点，我们可以发现flatMap 是堆栈安全的，因为Pull 本质上是FreeC 的包装器，即trampolined。）

用tailRecM 重写tk 可能并不难，尽管我们必须添加否则不必要的ApplicativeError 约束。我猜文档的作者为了清楚起见选择不这样做，因为他们知道Pull 的flatMap 很好。

---

更新：这是一个相当机械的tailRecM 翻译：

import cats.ApplicativeError
import fs2._

def tk[F[_], O](n: Long)(implicit F: ApplicativeError[F, Throwable]): Pipe[F, O, O] =
  in => Pull.syncInstance[F, O].tailRecM((in, n)) {
    case (s, n) => s.pull.uncons.flatMap {
      case Some((hd, tl)) =>
        hd.size match {
          case m if m <= n => Pull.output(hd).as(Left((tl, n - m)))
          case m => Pull.output(hd.take(n.toInt)).as(Right(()))
        }
      case None => Pull.pure(Right(()))
    }
  }.stream

请注意，没有显式递归。

---

第二个问题的答案取决于其他方法的外观，但在您的具体示例中，>> 只会导致更多的flatMap 层，所以应该没问题。

为了更笼统地解决您的问题，整个主题在 Scala 中是一团乱麻。您不必像我们上面所做的那样深入研究实现，只是为了知道一个类型是否支持堆栈安全的单子递归。更好的文档约定在这里会有所帮助，但不幸的是，我们在这方面做得并不好。您始终可以使用 tailRecM 来“安全”（无论如何，当 F[_] 是通用的时，您会想要这样做），但即便如此，您仍然相信 Monad 实现是合法的。

总结：这是一个糟糕的情况，在敏感的情况下，你绝对应该编写自己的测试来验证这样的实现是堆栈安全的。