尝试从io monad中从爪哇扫描仪阅读时，无限循环

Question

我试图为猫效应课程做一个练习，其中要求我逐行阅读文档，并等待两行之间的一定时间。

老师的解决方案如下：

def readLines(sc: Scanner): IO[Unit] =
  if sc.hasNextLine then IO(sc.nextLine).debug *> IO.sleep(1.second) *> readLines(sc)
  else IO.unit

但是，我试图从上面的同一功能创建一个尾部回复功能，看起来像这样：

def readLines(sc: Scanner): IO[Unit] =

  @tailrec
  def tailReader(accum: IO[Unit]): IO[Unit] =

    if sc.hasNextLine then tailReader(accum *> IO(sc.nextLine).debug *> IO.sleep(1.second))
    else accum

  tailReader(IO.unit)

end readLines

问题是，第一个实现确实是按行读取行并完成的。另一方面，我的实现从未完成，甚至从未读过文档的第一行，然后是OutofMemoryError。

我的问题是，有什么办法可以以一种尾巴回报和纯粹功能性的方式实施第一个功能？

我知道有一种方法可以通过使用＆gt;＆gt;运算符而不是*＆gt;一个来制作第一个实现堆栈安全。但是，这不是我要寻找的，而是我希望能够使用@TailRec注释。

我能够部分解决该错误的方式是在功能开头创建一个值，该值将当前行从扫描仪中保存到扫描仪，这样解决了问题：

def readLines(sc: Scanner): IO[Unit] =

  @tailrec
  def tailReader(accum: IO[Unit]): IO[Unit] =

    val currentLine = sc.nextLine

    if sc.hasNextLine then tailReader(accum *> IO(currentLine).debug *> IO.sleep(1.second))
    else accum >> IO(currentLine).debug.void

  tailReader(IO.unit)

end readLines

尽管这解决了问题，但我很确定该解决方案不是纯粹的功能。

如果您能给我解决这个问题，我将非常感激，我才开始了解效果世界，您的帮助将派上用场！

对于其他一切，祝您有美好的一天。

Answer 1

一些澄清：

1. 关于＆gt;＆gt;和*＆gt;：

  def *>[B](that: IO[B]): IO[B] =
    productR(that)

  def productR[B](that: IO[B]): IO[B] =
    flatMap(_ => that)

  def >>[B](that: => IO[B]): IO[B] =
    flatMap(_ => that)

2. 您可以使用flatmap进行堆栈安全递归，因为 monad 是在猫中设计的。

我将在以下示例中与flatmap交换＆gt;＆gt;和*＆gt;因为已经保证了堆栈安全。

现在，这里有什么问题

def readLines(sc: Scanner): IO[Unit] = {

  def tailReader(accum: IO[Unit]): IO[Unit] = {
    if (sc.hasNextLine)
      tailReader { 
        accum
          .flatMap(_ => IO(sc.nextLine()))
          .flatMap(_ => IO.sleep(1.second))
      }
    else
      tailReader(accum)
  }

  tailReader(IO.unit)
}

我们正在检查sc.hasnextline，而未评估sc.nextline。
IO（sc.nextline）在这一点上只是一个描述，什么都没评估。

使flatmap链的递归调用部分解决此问题：

  def tailReader(accum: IO[Unit]): IO[Unit] = {
    if (sc.hasNextLine)
      IO(sc.nextLine())
        .flatMap(_ => IO.sleep(1.second))
        .flatMap(_ => tailReader(accum)) //make the call here
    else
      tailReader(accum)
  }

然后，递归方法还有另一个小问题。
tailreader（..）仅在检查下一行后才返回IO。

使用io.suspend与评估完全分开的定义。

   def tailReader(accum: IO[Unit]): IO[Unit] = IO.suspend {
    if (sc.hasNextLine)
      IO(sc.nextLine())
        .flatMap(_ => IO.sleep(1.second))
        .flatMap(_ => accum)
    else
      tailReader(accum)
  }

现在tailReader（io.unit）甚至一次返回IO，而无需调用hasnextline甚至一次。