Question

我正在使用一个提供Traversable [T]的库，该页面可以浏览数据库结果。我想避免将整个内容加载到内存中，因此我尝试将其转换为Stream [T]。

据我所知，内置＆＃34; asStream＆＃34;方法将整个Traversable加载到Buffer中，这违背了我的目的。我的尝试（下面）在大结果上遇到StackOverflowException，我无法说明原因。有人可以帮我理解发生了什么吗？谢谢！

def asStream[T](traversable: => Traversable[T]): Stream[T] = {
  if (traversable.isEmpty) Empty
  else {
    lazy val head = traversable.head
    lazy val tail = asStream(traversable.tail)
    head #:: tail
  }
}

根据@SCouto的建议

，这是一个完整的例子

import scala.collection.immutable.Stream.Empty

object StreamTest {
  def main(args: Array[String]) = {
    val bigVector = Vector.fill(90000)(1)
    val optionStream = asStream(bigVector).map(v => Some(v))
    val zipped = optionStream.zipAll(optionStream.tail, None, None)
  }

  def asStream[T](traversable: => Traversable[T]): Stream[T] = {
    @annotation.tailrec
    def loop(processed: => Stream[T], pending: => Traversable[T]): Stream[T] = {
      if (pending.isEmpty) processed
      else {
        lazy val head = pending.head
        lazy val tail = pending.tail
        loop(processed :+ head, tail)
      }
    }

    loop(Empty, traversable)
  }
}

编辑：在@SCouto的一些有趣的想法之后，我了解到这也可以通过蹦床将结果保持为原始顺序的Stream [T]

object StreamTest {
  def main(args: Array[String]) = {
    val bigVector = Range(1, 90000).toVector
    val optionStream = asStream(bigVector).map(v => Some(v))
    val zipped = optionStream.zipAll(optionStream.tail, None, None)
    zipped.take(10).foreach(println)
  }

  def asStream[T](traversable: => Traversable[T]): Stream[T] = {
    sealed trait Traversal[+R]
    case class More[+R](result: R, next: () => Traversal[R]) extends Traversal[R]
    case object Done extends Traversal[Nothing]

    def next(currentTraversable: Traversable[T]): Traversal[T] = {
      if (currentTraversable.isEmpty) Done
      else More(currentTraversable.head, () => next(currentTraversable.tail))
    }

    def trampoline[R](body: => Traversal[R]): Stream[R] = {
      def loop(thunk: () => Traversal[R]): Stream[R] = {
        thunk.apply match {
          case More(result, next) => Stream.cons(result, loop(next))
          case Done => Stream.empty
        }
      }
      loop(() => body)
    }

    trampoline(next(traversable))
  }
}

Answer 1

试试这个：

  def asStream[T](traversable: => Traversable[T]): Stream[T] = {

    @annotation.tailrec
    def loop(processed: Stream[T], pending: Traversable[T]): Stream[T] = {
      if (pending.isEmpty) processed
      else {
        lazy val head = pending.head
        lazy val tail = pending.tail
        loop(head #:: processed, tail)
      }
    }

    loop(Empty, traversable)
  }

重点是确保递归调用是递归函数的最后一个操作。

要确保这一点，您可以同时使用嵌套方法（示例中称为loop）和tailrec注释，以确保您的方法是尾部安全的。

你可以找到关于tail rec here的信息以及这个很棒的答案here

修改问题是我们在Stream的末尾添加了元素。如果您将其添加为Stream的头部，就像您的示例中一样，它将正常工作。我更新了我的代码。请测试一下，让我们知道结果。

我的测试：

scala> val optionStream = asStream(Vector.fill(90000)(1)).map(v => Some(v)) optionStream: scala.collection.immutable.Stream[Some[Int]] = Stream(Some(1), ?) scala> val zipped = optionStream.zipAll(optionStream.tail, None, None) zipped: scala.collection.immutable.Stream[(Option[Int], Option[Int])] = Stream((Some(1),Some(1)), ?)

<强> EDIT2：

根据你的评论，并考虑你所说的fpinscala例子。我想这可能会对你有所帮助。重点是创建一个具有延迟评估的案例类结构。头部是单个元素，尾部是可穿越的

sealed trait myStream[+T] { def head: Option[T] = this match { case MyEmpty => None case MyCons(h, _) => Some(h()) } def tail: myStream[T] = this match { case MyEmpty => MyEmpty case MyCons(_, t) => myStream.cons(t().head, t().tail) } } case object MyEmpty extends myStream[Nothing] case class MyCons[+T](h: () => T, t: () => Traversable[T]) extends myStream[T] object myStream { def cons[T](hd: => T, tl: => Traversable[T]): myStream[T] = { lazy val head = hd lazy val tail = tl MyCons(() => head, () => tail) } def empty[T]: myStream[T] = MyEmpty def apply[T](as: T*): myStream[T] = { if (as.isEmpty) empty else cons(as.head, as.tail) } }

一些快速测试：

val bigVector = Vector.fill(90000)(1) myStream.cons(bigVector.head, bigVector.tail) res2: myStream[Int] = MyCons(<function0>,<function0>)

检索头：

res2.head res3: Option[Int] = Some(1)

尾巴：

res2.tail res4: myStream[Int] = MyCons(<function0>,<function0>)

<强> EDIT3

op的蹦床解决方案：

def asStream[T](traversable: => Traversable[T]): Stream[T] = { sealed trait Traversal[+R] case class More[+R](result: R, next: () => Traversal[R]) extends Traversal[R] case object Done extends Traversal[Nothing] def next(currentTraversable: Traversable[T]): Traversal[T] = { if (currentTraversable.isEmpty) Done else More(currentTraversable.head, () => next(currentTraversable.tail)) } def trampoline[R](body: => Traversal[R]): Stream[R] = { def loop(thunk: () => Traversal[R]): Stream[R] = { thunk.apply match { case More(result, next) => Stream.cons(result, loop(next)) case Done => Stream.empty } } loop(() => body) } trampoline(next(traversable)) } }

Answer 2

Stream不会将数据保留在内存中，因为您声明了如何生成每个项目。您的数据库数据很可能不是在程序上生成的，因此您需要的是在第一次请求时获取数据（类似def getData(index: Int): Future[Data]）。

最大的问题是，因为你是从数据库中获取数据，所以你可能正在使用Future，所以，即使你能够实现它，你也会得到一个Future[Stream[Data]]个对象。是不是很好用，或者更糟糕的是阻止它。

仅对分页数据库数据查询不值得吗？

将Traversable [T]转换为Stream [T]而不进行遍历或堆栈溢出

2 个答案: