流类型的Scala递归实现

我已经开始在Coursera上学习Scala，对

squareRootGuess

实现有一些疑问，如下所示

我正试图实现标准来过滤

sqrtGuess

定义中的准确猜测，如下所示，但它给了我堆栈溢出错误

def sqrtGuess(x: Double): Stream[Double] = { 
  def nextGuess(guess: Double): Double = (guess + x / guess)/2

  def isSufficient(guess: Double): Boolean = math.abs(x - guess*guess)/x < 0.001

  def guesses: Stream[Double] = 
    1 #:: guesses.map(nextGuess).filter(isSufficient)

  guesses
}

---

我想知道

sqrtGuess

的第一个实现中发生了什么？我试图使用替代模型来证明这一点，但它似乎没有任何问题。

我假设您使用的是Scala 2.12，因为它在Scala 2.13中已被弃用，并带有以下弃用消息：

使用LazyList（完全懒惰）代替Stream（只有懒尾巴）

我没有真正的证据来证明我将要说的话，但我可以假设这是正在发生的事情：

在非工作示例中，您试图根据

x=4.2

和

guess=1.0

生成一个列表。过滤器将删除计算的下一个元素。因此，下一个不会添加到流中。因此，

猜测

总是无法为流创建一个新元素，而且流中永远不会有10个元素。堆栈溢出是由于无休止的递归造成的

为了进行过滤，您需要首先创建流，并对其进行过滤：

def sqrtGuess1(x: Double): Stream[Double] = {
  def nextGuess(guess: Double): Double = (guess + x / guess)/2

  def isSufficient(guess: Double): Boolean = math.abs(x - guess*guess)/x < 0.001

  def guesses: Stream[Double] =
    1 #:: guesses.map(nextGuess)

  guesses.filter(isSufficient)
}

def sqrtGuess1（x:Double）：流[Double]={
def nextGuess（猜测：Double）：Double=（猜测+x/猜测）/2
def issuefficient（guess:Double）：Boolean=math.abs（x-guess*guess）/x<0.001
def猜测：流[双精度]=
1.：：猜测。地图（下一步）
猜测。过滤器（不足）
}

谢谢，它很管用！就像你说的scala 2.12版，因为我学习的课程是老课程哈哈。

def sqrtGuess1(x: Double): Stream[Double] = {
  def nextGuess(guess: Double): Double = (guess + x / guess)/2

  def isSufficient(guess: Double): Boolean = math.abs(x - guess*guess)/x < 0.001

  def guesses: Stream[Double] =
    1 #:: guesses.map(nextGuess)

  guesses.filter(isSufficient)
}