Merge pull request scala#7573 from NthPortal/topic/ll-lazy-builder/PR

Add lazy builder for LazyList

Author: SethTisue

src/library/scala/collection/immutable/LazyList.scala

@@ -19,7 +19,7 @@ import java.lang.{StringBuilder => JStringBuilder}
 
 import scala.annotation.tailrec
 import scala.collection.generic.SerializeEnd
-import scala.collection.mutable.{ArrayBuffer, Builder, StringBuilder}
+import scala.collection.mutable.{ArrayBuffer, Builder, ReusableBuilder, StringBuilder}
 import scala.language.implicitConversions
 
 /**  The class `LazyList` implements lazy lists where elements
@@ -194,6 +194,10 @@ import scala.language.implicitConversions
   *  @define coll lazy list
   *  @define orderDependent
   *  @define orderDependentFold
+  *  @define appendStackSafety Note: Repeated chaining of calls to append methods (`appended`,
+  *                            `appendedAll`, `lazyAppendedAll`) without forcing any of the
+  *                            intermediate resulting lazy lists may overflow the stack when
+  *                            the final result is forced.
   */
 @SerialVersionUID(3L)
 final class LazyList[+A] private(private[this] var lazyState: () => LazyList.State[A])
@@ -300,6 +304,8 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
   override protected[this] def className = "LazyList"
 
   /** The lazy list resulting from the concatenation of this lazy list with the argument lazy list.
+    *
+    * $appendStackSafety
     *
     * @param suffix The collection that gets appended to this lazy list
     * @return The lazy list containing elements of this lazy list and the iterable object.
@@ -314,10 +320,18 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
       else sCons(head, tail lazyAppendedAll suffix)
     }
 
+  /** @inheritdoc
+    *
+    * $appendStackSafety
+    */
   override def appendedAll[B >: A](suffix: IterableOnce[B]): LazyList[B] =
     if (knownIsEmpty) LazyList.from(suffix)
     else lazyAppendedAll(suffix)
 
+  /** @inheritdoc
+    *
+    * $appendStackSafety
+    */
   override def appended[B >: A](elem: B): LazyList[B] =
     if (knownIsEmpty) newLL(sCons(elem, LazyList.empty))
     else lazyAppendedAll(Iterator.single(elem))
@@ -789,38 +803,6 @@ object LazyList extends SeqFactory[LazyList] {
     final class Cons[A](val head: A, val tail: LazyList[A]) extends State[A]
   }
 
-  private class SlidingIterator[A](private[this] var lazyList: LazyList[A], size: Int, step: Int)
-    extends AbstractIterator[LazyList[A]] {
-    private val minLen = size - step max 0
-    private var first = true
-
-    def hasNext: Boolean =
-      if (first) lazyList.nonEmpty
-      else lazyList.lengthGt(minLen)
-
-    def next(): LazyList[A] = {
-      if (!hasNext) Iterator.empty.next()
-      else {
-        first = false
-        val list = lazyList
-        lazyList = list.drop(step)
-        list.take(size)
-      }
-    }
-  }
-
-  private class LazyIterator[+A](private[this] var lazyList: LazyList[A]) extends AbstractIterator[A] {
-    override def hasNext: Boolean = lazyList.nonEmpty
-
-    override def next(): A =
-      if (lazyList.isEmpty) Iterator.empty.next()
-      else {
-        val res = lazyList.head
-        lazyList = lazyList.tail
-        res
-      }
-  }
-
   /** Creates a new LazyList. */
   @inline private def newLL[A](state: => State[A]): LazyList[A] = new LazyList[A](() => state)
 
@@ -886,15 +868,6 @@ object LazyList extends SeqFactory[LazyList] {
     if (!it.hasNext) State.Empty
     else stateFromIteratorConcatSuffix(it.next().iterator)(concatIterator(it))
 
-  private final class WithFilter[A] private[LazyList](lazyList: LazyList[A], p: A => Boolean)
-    extends collection.WithFilter[A, LazyList] {
-    private[this] val filtered = lazyList.filter(p)
-    def map[B](f: A => B): LazyList[B] = filtered.map(f)
-    def flatMap[B](f: A => IterableOnce[B]): LazyList[B] = filtered.flatMap(f)
-    def foreach[U](f: A => U): Unit = filtered.foreach(f)
-    def withFilter(q: A => Boolean): collection.WithFilter[A, LazyList] = new WithFilter(filtered, q)
-  }
-
   /** An infinite LazyList that repeatedly applies a given function to a start value.
     *
     *  @param start the start value of the LazyList
@@ -954,7 +927,103 @@ object LazyList extends SeqFactory[LazyList] {
       }
     }
 
-  def newBuilder[A]: Builder[A, LazyList[A]] = ArrayBuffer.newBuilder[A].mapResult(array => from(array))
+  def newBuilder[A]: Builder[A, LazyList[A]] = new LazyBuilder[A]
+
+  private class LazyIterator[+A](private[this] var lazyList: LazyList[A]) extends AbstractIterator[A] {
+    override def hasNext: Boolean = lazyList.nonEmpty
+
+    override def next(): A =
+      if (lazyList.isEmpty) Iterator.empty.next()
+      else {
+        val res = lazyList.head
+        lazyList = lazyList.tail
+        res
+      }
+  }
+
+  private class SlidingIterator[A](private[this] var lazyList: LazyList[A], size: Int, step: Int)
+    extends AbstractIterator[LazyList[A]] {
+    private val minLen = size - step max 0
+    private var first = true
+
+    def hasNext: Boolean =
+      if (first) lazyList.nonEmpty
+      else lazyList.lengthGt(minLen)
+
+    def next(): LazyList[A] = {
+      if (!hasNext) Iterator.empty.next()
+      else {
+        first = false
+        val list = lazyList
+        lazyList = list.drop(step)
+        list.take(size)
+      }
+    }
+  }
+
+  private final class WithFilter[A] private[LazyList](lazyList: LazyList[A], p: A => Boolean)
+    extends collection.WithFilter[A, LazyList] {
+    private[this] val filtered = lazyList.filter(p)
+    def map[B](f: A => B): LazyList[B] = filtered.map(f)
+    def flatMap[B](f: A => IterableOnce[B]): LazyList[B] = filtered.flatMap(f)
+    def foreach[U](f: A => U): Unit = filtered.foreach(f)
+    def withFilter(q: A => Boolean): collection.WithFilter[A, LazyList] = new WithFilter(filtered, q)
+  }
+
+  private final class LazyBuilder[A] extends ReusableBuilder[A, LazyList[A]] {
+    import LazyBuilder._
+
+    private[this] var next: DeferredState[A] = _
+    private[this] var list: LazyList[A] = _
+
+    clear()
+
+    override def clear(): Unit = {
+      val deferred = new DeferredState[A]
+      list = newLL(deferred.eval())
+      next = deferred
+    }
+
+    override def result(): LazyList[A] = {
+      next init State.Empty
+      list
+    }
+
+    override def addOne(elem: A): this.type = {
+      val deferred = new DeferredState[A]
+      next init sCons(elem, newLL(deferred.eval()))
+      next = deferred
+      this
+    }
+
+    // lazy implementation which doesn't evaluate the collection being added
+    override def addAll(xs: IterableOnce[A]): this.type = {
+      if (xs.knownSize != 0) {
+        val deferred = new DeferredState[A]
+        next init stateFromIteratorConcatSuffix(xs.iterator)(deferred.eval())
+        next = deferred
+      }
+      this
+    }
+  }
+
+  private object LazyBuilder {
+    final class DeferredState[A] {
+      private[this] var _state: () => State[A] = _
+
+      def eval(): State[A] = {
+        val state = _state
+        if (state == null) throw new IllegalStateException("uninitialized")
+        state()
+      }
+
+      // racy
+      def init(state: => State[A]): Unit = {
+        if (_state != null) throw new IllegalStateException("already initialized")
+        _state = () => state
+      }
+    }
+  }
 
   /** This serialization proxy is used for LazyLists which start with a sequence of evaluated cons cells.
     * The forced sequence is serialized in a compact, sequential format, followed by the unevaluated tail, which uses

test/junit/scala/collection/immutable/LazyListLazinessTest.scala

@@ -881,6 +881,13 @@ class LazyListLazinessTest {
   def unapplySeq_properlyLazy(): Unit = {
     genericLazyOp_properlyLazy(LazyList.unapplySeq(_).toSeq.to(LazyList))
   }
+
+  @Test
+  def builder_properlyLazy(): Unit = {
+    val op = lazyListOp { ll => (LazyList.newBuilder[Int] ++= ll).result() }
+    assertLazyAll(op)
+    assertRepeatedlyLazy(op)
+  }
 }
 
 private object LazyListLazinessTest {

test/junit/scala/collection/immutable/LazyListTest.scala

@@ -1,12 +1,12 @@
-package scala.collection.immutable
+package scala.collection
+package immutable
 
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 import org.junit.Test
 import org.junit.Assert._
 
-import scala.collection.Iterator
-import scala.collection.mutable.ListBuffer
+import scala.collection.mutable.{Builder, ListBuffer}
 import scala.ref.WeakReference
 import scala.tools.testing.AssertUtil
 import scala.util.Try
@@ -383,4 +383,21 @@ class LazyListTest {
     check(LazyList.from(Vector(1, 2, 3, 4, 5)))
     check(LazyList.tabulate(5)(_ + 1))
   }
+
+  @Test
+  def builder(): Unit = {
+    def build(init: Builder[Int, LazyList[Int]] => Unit): LazyList[Int] = {
+      val b = LazyList.newBuilder[Int]
+      init(b)
+      b.result()
+    }
+
+    assertEquals(Nil, build(_ => ()))
+    assertEquals(Nil, build(_ ++= Nil))
+    assertEquals(Nil, build(_ ++= LazyList.empty))
+    assertEquals(1 to 10, build(_ += 1 ++= (2 to 5) += 6 += 7 ++= (8 to 10)))
+    assertEquals(1 to 10, build(_ ++= (1 to 4) ++= (5 to 6) += 7 ++= (8 to 9) += 10))
+    assertEquals(1 to 10, build(_ ++= LazyList.from(1).take(10)))
+    assertEquals(1 to 10, build(_ ++= Iterator.from(1).take(10)))
+  }
 }

test/scalacheck/scala/collection/immutable/SeqProperties.scala

@@ -18,7 +18,6 @@ object SeqProperties extends Properties("immutable.Seq builder implementations")
   property("Seq builder stateful testing") = new SeqBuilderStateProperties(Seq.newBuilder[A]).property()
   property("List builder stateful testing") = new SeqBuilderStateProperties(List.newBuilder[A]).property()
   property("ArraySeq builder stateful testing") = new SeqBuilderStateProperties(ArraySeq.newBuilder[A]).property()
-  property("LazyList builder stateful testing") = new SeqBuilderStateProperties(LazyList.newBuilder[A]).property()
   property("Queue builder stateful testing") = new SeqBuilderStateProperties(Queue.newBuilder[A]).property()
   property("IndexedSeq builder stateful testing") = new SeqBuilderStateProperties(IndexedSeq.newBuilder[A]).property()
   property("Stream builder stateful testing") = new SeqBuilderStateProperties(Stream.newBuilder[A]).property()