Stop Stream from sharing implementation with LazyList

Extract Stream into its own file, and inline methods and
implementation into Stream or its companion object.

Author: NthPortal

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

@@ -693,189 +693,3 @@ object LazyList extends LazyListFactory[LazyList] {
   private[this] def writeObject(out: ObjectOutputStream): Unit = ()
   private[this] def readObject(in: ObjectInputStream): Unit = ()
 }
-
-@deprecated("Use LazyList (which has a lazy head and tail) instead of Stream (which has a lazy tail only)", "2.13.0")
-@SerialVersionUID(3L)
-sealed abstract class Stream[+A] extends AbstractSeq[A] with LinearSeq[A] with LazyListOps[A, Stream, Stream[A]] {
-  override def iterableFactory: LazyListFactory[Stream] = Stream
-
-  override protected[this] def className: String = "Stream"
-
-  protected def cons[T](hd: => T, tl: => Stream[T]): Stream[T] = new Stream.Cons(hd, tl)
-
-  /** Apply the given function `f` to each element of this linear sequence
-    * (while respecting the order of the elements).
-    *
-    *  @param f The treatment to apply to each element.
-    *  @note  Overridden here as final to trigger tail-call optimization, which
-    *  replaces 'this' with 'tail' at each iteration. This is absolutely
-    *  necessary for allowing the GC to collect the underlying LazyList as elements
-    *  are consumed.
-    *  @note  This function will force the realization of the entire LazyList
-    *  unless the `f` throws an exception.
-    */
-  @tailrec
-  override final def foreach[U](f: A => U): Unit = {
-    if (!this.isEmpty) {
-      f(head)
-      tail.foreach(f)
-    }
-  }
-
-  override def take(n: Int): Stream[A] = {
-    if (n <= 0 || isEmpty) Stream.empty
-    else if (n == 1) new Stream.Cons(head, Stream.empty)
-    else new Stream.Cons(head, tail.take(n - 1))
-  }
-
-  /** LazyList specialization of foldLeft which allows GC to collect along the
-    * way.
-    *
-    * @tparam B The type of value being accumulated.
-    * @param z The initial value seeded into the function `op`.
-    * @param op The operation to perform on successive elements of the `LazyList`.
-    * @return The accumulated value from successive applications of `op`.
-    */
-  @tailrec
-  override final def foldLeft[B](z: B)(op: (B, A) => B): B = {
-    if (this.isEmpty) z
-    else tail.foldLeft(op(z, head))(op)
-  }
-
-  @deprecated("The `append` operation has been renamed `lazyAppendedAll`", "2.13.0")
-  @inline final def append[B >: A](suffix: IterableOnce[B]): Stream[B] = lazyAppendedAll(suffix)
-
-  override protected[this] def writeReplace(): AnyRef =
-    if(headDefined && tailDefined) new LazyListOps.SerializationProxy[A, Stream](this) else this
-
-  /** Prints elements of this stream one by one, separated by commas. */
-  @deprecated(message = """Use print(stream.force.mkString(", ")) instead""", since = "2.13.0")
-  @inline def print(): Unit = Console.print(this.force.mkString(", "))
-
-  /** Prints elements of this stream one by one, separated by `sep`.
-    *  @param sep   The separator string printed between consecutive elements.
-    */
-  @deprecated(message = "Use print(stream.force.mkString(sep)) instead", since = "2.13.0")
-  @inline def print(sep: String): Unit = Console.print(this.force.mkString(sep))
-
-}
-
-@deprecated("Use LazyList (which has a lazy head and tail) instead of Stream (which has a lazy tail only)", "2.13.0")
-@SerialVersionUID(3L)
-object Stream extends LazyListFactory[Stream] {
-
-  protected def newCons[T](hd: => T, tl: => Stream[T]): Stream[T] = new Stream.Cons(hd, tl)
-
-  //@SerialVersionUID(3L) //TODO Putting an annotation on Stream.empty causes a cyclic dependency in unpickling
-  object Empty extends Stream[Nothing] {
-    override def isEmpty: Boolean = true
-    override def head: Nothing = throw new NoSuchElementException("head of empty stream")
-    override def tail: Stream[Nothing] = throw new UnsupportedOperationException("tail of empty stream")
-    /** Forces evaluation of the whole `Stream` and returns it.
-      *
-      * @note Often we use `Stream`s to represent an infinite set or series.  If
-      * that's the case for your particular `Stream` then this function will never
-      * return and will probably crash the VM with an `OutOfMemory` exception.
-      * This function will not hang on a finite cycle, however.
-      *
-      *  @return The fully realized `Stream`.
-      */
-    def force: this.type = this
-    override def knownSize: Int = 0
-    override def iterator: Iterator[Nothing] = Iterator.empty
-    protected def headDefined: Boolean = false
-    protected def tailDefined: Boolean = false
-  }
-
-  @SerialVersionUID(3L)
-  final class Cons[A](override val head: A, tl: => Stream[A]) extends Stream[A] {
-    private[this] var tlEvaluated: Boolean = false
-    override def isEmpty: Boolean = false
-    override lazy val tail: Stream[A] = {
-      tlEvaluated = true
-      tl
-    }
-    protected def headDefined: Boolean = true
-    protected def tailDefined: Boolean = tlEvaluated
-    /** Forces evaluation of the whole `Stream` and returns it.
-      *
-      * @note Often we use `Stream`s to represent an infinite set or series.  If
-      * that's the case for your particular `Stream` then this function will never
-      * return and will probably crash the VM with an `OutOfMemory` exception.
-      * This function will not hang on a finite cycle, however.
-      *
-      *  @return The fully realized `Stream`.
-      */
-    def force: this.type = {
-      // Use standard 2x 1x iterator trick for cycle detection ("those" is slow one)
-      var these, those: Stream[A] = this
-      if (!these.isEmpty) these = these.tail
-      while (those ne these) {
-        if (these.isEmpty) return this
-        these = these.tail
-        if (these.isEmpty) return this
-        these = these.tail
-        if (these eq those) return this
-        those = those.tail
-      }
-      this
-    }
-
-  }
-
-  /** An alternative way of building and matching Streams using Stream.cons(hd, tl).
-    */
-  object cons {
-    /** A stream consisting of a given first element and remaining elements
-      *  @param hd   The first element of the result stream
-      *  @param tl   The remaining elements of the result stream
-      */
-    def apply[A](hd: A, tl: => Stream[A]): Stream[A] = new Cons(hd, tl)
-
-    /** Maps a stream to its head and tail */
-    def unapply[A](xs: Stream[A]): Option[(A, Stream[A])] = #::.unapply(xs)
-  }
-
-  implicit def toDeferrer[A](l: => Stream[A]): Deferrer[A] = new Deferrer[A](() => l)
-
-  final class Deferrer[A] private[Stream] (private val l: () => Stream[A]) extends AnyVal {
-    /** Construct a Stream consisting of a given first element followed by elements
-      *  from another Stream.
-      */
-    def #:: [B >: A](elem: B): Stream[B] = new Cons(elem, l())
-    /** Construct a Stream consisting of the concatenation of the given Stream and
-      *  another Stream.
-      */
-    def #:::[B >: A](prefix: Stream[B]): Stream[B] = prefix lazyAppendedAll l()
-  }
-
-  object #:: {
-    def unapply[A](s: Stream[A]): Option[(A, Stream[A])] =
-      if (s.nonEmpty) Some((s.head, s.tail)) else None
-  }
-
-  def from[A](coll: collection.IterableOnce[A]): Stream[A] = coll match {
-    case coll: Stream[A] => coll
-    case _ => fromIterator(coll.iterator)
-  }
-
-  /**
-    * @return A `Stream[A]` that gets its elements from the given `Iterator`.
-    *
-    * @param it Source iterator
-    * @tparam A type of elements
-    */
-  // Note that the resulting `Stream` will be effectively iterable more than once because
-  // `Stream` memoizes its elements
-  def fromIterator[A](it: Iterator[A]): Stream[A] =
-    if (it.hasNext) {
-      new Stream.Cons(it.next(), fromIterator(it))
-    } else Stream.Empty
-
-  def empty[A]: Stream[A] = Empty
-
-  // scalac generates a `readReplace` method to discard the deserialized state (see https://github.com/scala/bug/issues/10412).
-  // This prevents it from serializing it in the first place:
-  private[this] def writeObject(out: ObjectOutputStream): Unit = ()
-  private[this] def readObject(in: ObjectInputStream): Unit = ()
-}