migrations.scala

Byte
  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def <<(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>>(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>(x: Long): Int

Char

  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def <<(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>>(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>(x: Long): Int

Int
  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def <<(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>>(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  edef >>(x: Long): Int
  
Short

  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def <<(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>>(x: Long): Int

  @deprecated("shifting a value by a `Long` argument is deprecated (except when the value is a `Long`).\nCall `toInt` on the argument to maintain the current behavior and avoid the deprecation warning.", "2.12.7")
  def >>(x: Long): Int

Double

  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String

Float

  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String

Long

  @deprecated("Adding a number and a String is deprecated. Convert the number to a String with `toString` first to call +", "2.13.0")
  def +(x: String): String


Function

  // @deprecated("use `f.tupled` instead")
  def tupled[a1, a2, b](f: (a1, a2) => b): Tuple2[a1, a2] => b
  def tupled[a1, a2, a3, b](f: (a1, a2, a3) => b): Tuple3[a1, a2, a3] => b
  def tupled[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): Tuple4[a1, a2, a3, a4] => b
  def tupled[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): Tuple5[a1, a2, a3, a4, a5] => b


scala
  @deprecated("Use IterableOnce instead of TraversableOnce", "2.13.0")
  type TraversableOnce[+A] = scala.collection.IterableOnce[A]

  @deprecated("Use Iterable instead of Traversable", "2.13.0")
  type Traversable[+A] = scala.collection.Iterable[A]

  @deprecated("Use Iterable instead of Traversable", "2.13.0")
  val Traversable = scala.collection.Iterable

  @deprecated("Use scala.collection.BufferedIterator instead of scala.BufferedIterator", "2.13.0")
  type BufferedIterator[+A] = scala.collection.BufferedIterator[A]

scala.collection.generic

  @deprecated("Clearable was moved from collection.generic to collection.mutable", "2.13.0")
  type Clearable = scala.collection.mutable.Clearable

  @deprecated("Use scala.collection.BuildFrom instead", "2.13.0")
  type CanBuildFrom[-From, -A, +C] = scala.collection.BuildFrom[From, A, C]

scala.collection

  @deprecated("Use Iterable instead of Traversable", "2.13.0")
  type Traversable[+X] = Iterable[X]

  @deprecated("Use Iterable instead of Traversable", "2.13.0")
  val Traversable = Iterable

  @deprecated("Use IterableOnce instead of TraversableOnce", "2.13.0")
  type TraversableOnce[+X] = IterableOnce[X]

  @deprecated("Use IterableOnce instead of TraversableOnce", "2.13.0")
  val TraversableOnce = IterableOnce

  @deprecated("Use SeqOps instead of SeqLike", "2.13.0")
  type SeqLike[A, T] = SeqOps[A, Seq, T]

  @deprecated("Use SeqOps (for the methods) or IndexedSeqOps (for fast indexed access) instead of ArrayLike", "2.13.0")
  type ArrayLike[A] = SeqOps[A, Seq, Seq[A]]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  type GenTraversableOnce[+X] = IterableOnce[X]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  val GenTraversableOnce = IterableOnce

  @deprecated("Gen* collection types have been removed", "2.13.0")
  type GenTraversable[+X] = Iterable[X]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  val GenTraversable = Iterable

  @deprecated("Gen* collection types have been removed", "2.13.0")
  type GenIterable[+X] = Iterable[X]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  val GenIterable = Iterable

  @deprecated("Gen* collection types have been removed", "2.13.0")
  type GenSeq[+X] = Seq[X]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  val GenSeq = Seq

  @deprecated("Gen* collection types have been removed", "2.13.0")
  type GenSet[X] = Set[X]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  val GenSet = Set

  @deprecated("Gen* collection types have been removed", "2.13.0")
  type GenMap[K, +V] = Map[K, V]

  @deprecated("Gen* collection types have been removed", "2.13.0")
  val GenMap = Map

  @deprecated("DefaultMap is no longer necessary; extend Map directly", "2.13.0")
  trait DefaultMap[K, +V] extends Map[K, V]


  Searching

    @deprecated("Search methods are defined directly on SeqOps and do not require scala.collection.Searching any more", "2.13.0")
    class SearchImpl[Repr, A](private val coll: SeqOps[A, AnyConstr, _]) extends AnyVal

    @deprecated("Search methods are defined directly on SeqOps and do not require scala.collection.Searching any more", "2.13.0")
    implicit def search[Repr, A](coll: Repr)(implicit fr: IsSeqLike[Repr]): SearchImpl[Repr, fr.A]

  Seq

    @deprecated("Use `concat` instead", "2.13.0")
    @inline final def union[B >: A, That](that: Seq[B]): CC[B] = concat(that)

    @deprecated("Use segmentLength instead of prefixLength", "2.13.0")
    @`inline` final def prefixLength(p: A => Boolean): Int = segmentLength(p, 0)

    @deprecated("Use .reverseIterator.map(f).to(...) instead of .reverseMap(f)", "2.13.0")
    def reverseMap[B](f: A => B): CC[B] = fromIterable(new View.Map(View.fromIteratorProvider(() => reverseIterator), f))

  Set

    @deprecated("Use &~ or diff instead of --", "2.13.0")
    @`inline` final def -- (that: Set[A]): C = diff(that)

    @deprecated("Consider requiring an immutable Set or fall back to Set.diff", "2.13.0")
    def - (elem: A): C = diff(Set(elem))

    @deprecated("Use &- with an explicit collection argument instead of - with varargs", "2.13.0")
    def - (elem1: A, elem2: A, elems: A*): C = diff(elems.toSet + elem1 + elem2)

    @deprecated("Consider requiring an immutable Set or fall back to Set.union", "2.13.0")
    def + (elem: A): C = fromSpecificIterable(new View.Appended(toIterable, elem))

    @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
    def + (elem1: A, elem2: A, elems: A*): C = fromSpecificIterable(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))

  SortedMap

    @deprecated("Consider requiring an immutable Map or fall back to Map.concat", "2.13.0")
    override def + [V1 >: V](kv: (K, V1)): CC[K, V1] = sortedMapFactory.from(new View.Appended(toIterable, kv))

    @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
    override def + [V1 >: V](elem1: (K, V1), elem2: (K, V1), elems: (K, V1)*): CC[K, V1] = sortedMapFactory.from(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))

  SortedOps

    @deprecated("Use rangeFrom", "2.13.0")
    final def from(from: A): C = rangeFrom(from)

    @deprecated("Use rangeUntil", "2.13.0")
    final def until(until: A): C = rangeUntil(until)

    @deprecated("Use rangeTo", "2.13.0")
    final def to(to: A): C = rangeTo(to)

  StringOps
    @deprecated("Use `new WrappedString(s).diff(...).self` instead of `s.diff(...)`", "2.13.0")
    def diff(that: Seq[_ >: Char]): String = new WrappedString(s).diff(that).self

    @deprecated("Use `new WrappedString(s).intersect(...).self` instead of `s.intersect(...)`", "2.13.0")
    def intersect(that: Seq[_ >: Char]): String = new WrappedString(s).intersect(that).self

    @deprecated("Use `new WrappedString(s).distinct.self` instead of `s.distinct`", "2.13.0")
    def distinct: String = new WrappedString(s).distinct.self

    @deprecated("Use `new WrappedString(s).distinctBy(...).self` instead of `s.distinctBy(...)`", "2.13.0")
    def distinctBy[B](f: Char => B): String = new WrappedString(s).distinctBy(f).self

    @deprecated("Use `new WrappedString(s).sorted.self` instead of `s.sorted`", "2.13.0")
    def sorted[B >: Char](implicit ord: Ordering[B]): String = new WrappedString(s).sorted(ord).self

    @deprecated("Use `new WrappedString(s).sortWith(...).self` instead of `s.sortWith(...)`", "2.13.0")
    def sortWith(lt: (Char, Char) => Boolean): String = new WrappedString(s).sortWith(lt).self

    @deprecated("Use `new WrappedString(s).sortBy(...).self` instead of `s.sortBy(...)`", "2.13.0")
    def sortBy[B](f: Char => B)(implicit ord: Ordering[B]): String = new WrappedString(s).sortBy(f)(ord).self

    @deprecated("Use `new WrappedString(s).groupBy(...).mapValues(_.self)` instead of `s.groupBy(...)`", "2.13.0")
    def groupBy[K](f: Char => K): immutable.Map[K, String] = new WrappedString(s).groupBy(f).mapValues(_.self).toMap

    @deprecated("Use `new WrappedString(s).sliding(...).map(_.self)` instead of `s.sliding(...)`", "2.13.0")
    def sliding(size: Int, step: Int = 1): Iterator[String] = new WrappedString(s).sliding(size, step).map(_.self)

    @deprecated("Use `new WrappedString(s).combinations(...).map(_.self)` instead of `s.combinations(...)`", "2.13.0")
    def combinations(n: Int): Iterator[String] = new WrappedString(s).combinations(n).map(_.self)

    @deprecated("Use `new WrappedString(s).permutations(...).map(_.self)` instead of `s.permutations(...)`", "2.13.0")
    def permutations: Iterator[String] = new WrappedString(s).permutations.map(_.self)

  View

    @deprecated("Views no longer know about their underlying collection type; .force always returns an IndexedSeq", "2.13.0")
    @`inline` def force: IndexedSeq[A] = toIndexedSeq


  Iterable
    @deprecated("Iterable.seq always returns the iterable itself", "2.13.0")
    def seq: this.type = this

    @deprecated("Use .knownSize >=0 instead of .hasDefiniteSize", "2.13.0")
    @`inline` final def hasDefiniteSize = knownSize >= 0

    @deprecated("Use .view.slice(from, until) instead of .view(from, until)", "2.13.0")
    @`inline` final def view(from: Int, until: Int): View[A]

  IterableOnce
    @deprecated("Use .iterator.foreach(...) instead of .foreach(...) on IterableOnce", "2.13.0")
    @`inline` def foreach[U](f: A => U): Unit

    @deprecated("Use factory.from(it) instead of it.to(factory) for IterableOnce", "2.13.0")
    def to[C1](factory: Factory[A, C1]): C1

    @deprecated("Use ArrayBuffer.from(it) instead of it.toBuffer", "2.13.0")
    def toBuffer[B >: A]: mutable.Buffer[B]

    @deprecated("Use ArrayBuffer.from(it).toArray", "2.13.0")
    def toArray[B >: A: ClassTag]: Array[B]

    @deprecated("Use List.from(it) instead of it.toList", "2.13.0")
    def toList: immutable.List[A] = immutable.List.from(it)

    @deprecated("Use Set.from(it) instead of it.toSet", "2.13.0")
    @`inline` def toSet[B >: A]: immutable.Set[B] = immutable.Set.from(it)

    @deprecated("Use Iterable.from(it) instead of it.toIterable", "2.13.0")
    @`inline` final def toIterable: Iterable[A] = Iterable.from(it)

    @deprecated("Use Seq.from(it) instead of it.toSeq", "2.13.0")
    @`inline` def toSeq: immutable.Seq[A] = immutable.Seq.from(it)

    @deprecated("Use Stream.from(it) instead of it.toStream", "2.13.0")
    @`inline` def toStream: immutable.Stream[A] = immutable.Stream.from(it)

    @deprecated("Use Vector.from(it) instead of it.toVector on IterableOnce", "2.13.0")
    @`inline` def toVector: immutable.Vector[A] = immutable.Vector.from(it)

    @deprecated("Use Map.from(it) instead of it.toMap on IterableOnce", "2.13.0")
    def toMap[K, V](implicit ev: A <:< (K, V)): immutable.Map[K, V]

    @deprecated("toIterator has been renamed to iterator", "2.13.0")
    @`inline` def toIterator: Iterator[A] = it.iterator

    @deprecated("Use .iterator.isEmpty instead of .isEmpty on IterableOnce", "2.13.0")
    def isEmpty: Boolean

    @deprecated("Use .iterator.mkString instead of .mkString on IterableOnce", "2.13.0")
    def mkString(start: String, sep: String, end: String): String

    @deprecated("Use .iterator.mkString instead of .mkString on IterableOnce", "2.13.0")
    def mkString(sep: String): String

    @deprecated("Use .iterator.mkString instead of .mkString on IterableOnce", "2.13.0")
    def mkString: String = it match

    @deprecated("Use .iterator.find instead of .find on IterableOnce", "2.13.0")
    def find(p: A => Boolean): Option[A]

    @deprecated("Use .iterator.foldLeft instead of .foldLeft on IterableOnce", "2.13.0")
    @`inline` def foldLeft[B](z: B)(op: (B, A) => B): B

    @deprecated("Use .iterator.foldRight instead of .foldLeft on IterableOnce", "2.13.0")
    @`inline` def foldRight[B](z: B)(op: (A, B) => B): B

    @deprecated("Use .iterator.fold instead of .fold on IterableOnce", "2.13.0")
    def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1

    @deprecated("Use .iterator.foldLeft instead of /: on IterableOnce", "2.13.0")
    @`inline` def /: [B](z: B)(op: (B, A) => B): B

    @deprecated("Use .iterator.foldRight instead of :\\ on IterableOnce", "2.13.0")
    @`inline` def :\ [B](z: B)(op: (A, B) => B): B

    @deprecated("Use .iterator.map instead of .map on IterableOnce or consider requiring an Iterable", "2.13.0")
    def map[B](f: A => B): IterableOnce[B]

    @deprecated("Use .iterator.flatMap instead of .flatMap on IterableOnce or consider requiring an Iterable", "2.13.0")
    def flatMap[B](f: A => IterableOnce[B]): IterableOnce[B]

    @deprecated("Use .iterator.sameElements for sameElements on Iterable or IterableOnce", "2.13.0")
    def sameElements[B >: A](that: IterableOnce[B]): Boolean

Map

  @deprecated("Use - or remove on an immutable Map", "2.13.0")
  def - (key: K): Map[K, V]

  @deprecated("Use -- or removeAll on an immutable Map", "2.13.0")
  def - (key1: K, key2: K, keys: K*): Map[K, V]

TreeMap

  @deprecated("Use `updated` instead", "2.13.0")
  def insert[V1 >: V](key: K, value: V1): TreeMap[K, V1]

AnyRefMap

  @deprecated("Consider requiring an immutable Map or fall back to Map.concat", "2.13.0")
  override def + [V1 >: V](kv: (K, V1)): AnyRefMap[K, V1] = AnyRefMap.from(new View.Appended(toIterable, kv))

  @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
  override def + [V1 >: V](elem1: (K, V1), elem2: (K, V1), elems: (K, V1)*): AnyRefMap[K, V1] = AnyRefMap.from(new View.Concat(new View.Appended(new View.Appended(toIterable, elem1), elem2), elems))

  @deprecated("Use AnyRefMap.from(m).add(k,v) instead of m.updated(k, v)", "2.13.0")
  def updated[V1 >: V](key: K, value: V1): AnyRefMap[K, V1] = {

mutable
  @deprecated("Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays", "2.13.0")
  type WrappedArray[X] = ArraySeq[X]
  
  @deprecated("Use ArraySeq instead of WrappedArray; it can represent both, boxed and unboxed arrays", "2.13.0")
  val WrappedArray = ArraySeq
  
  @deprecated("Use Iterable instead of Traversable", "2.13.0")
  type Traversable[X] = Iterable[X]
  
  @deprecated("Use Iterable instead of Traversable", "2.13.0")
  val Traversable = Iterable
  
  @deprecated("Use Stack instead of ArrayStack; it now uses an array-based implementation", "2.13.0")
  type ArrayStack[X] = Stack[X]
  
  @deprecated("Use Stack instead of ArrayStack; it now uses an array-based implementation", "2.13.0")
  val ArrayStack = Stack

  @deprecated("mutable.LinearSeq has been removed; use LinearSeq with mutable.Seq instead", "2.13.0")
  type LinearSeq[X] = Seq[X] with scala.collection.LinearSeq[X]

  @deprecated("GrowingBuilder has been renamed to GrowableBuilder", "2.13.0")
  type GrowingBuilder[Elem, To <: Growable[Elem]] = GrowableBuilder[Elem, To]

  @deprecated("Use an immutable.ListMap assigned to a var instead of mutable.ListMap", "2.13.0")
  class ListMap[K, V]

  @deprecated("Use HashMap or one of the specialized versions (LongMap, AnyRefMap) instead of OpenHashMap", "2.13.0")
  object OpenHashMap

  Buffer

    @deprecated("Use .addOne or += instead of .append", "2.13.0")
    @`inline` final def append(elem: A): this.type = addOne(elem)

  Builder

    @deprecated("Use reverseInPlace instead", "2.13.0")
    final def reverseContents(): this.type = reverseInPlace()

  StringBuilder
    @deprecated("Use `new StringBuilder()` instead of `StringBuilder.newBuilder`", "2.13.0")
    def newBuilder = new StringBuilder

  IterableOps
    @deprecated("Use `mapInPlace` instead", "2.13.0")
    @`inline`final def transform(f: A => A): this.type = mapInPlace(f)

  LongMap
    @deprecated("Consider requiring an immutable Map or fall back to Map.concat", "2.13.0")
    override def +[V1 >: V](kv: (Long, V1)): LongMap[V1] = {

    @deprecated("Use ++ with an explicit collection argument instead of + with varargs", "2.13.0")
    override def + [V1 >: V](elem1: (Long, V1), elem2: (Long, V1), elems: (Long, V1)*): LongMap[V1]

    @deprecated("Use LongMap.from(m).add(k,v) instead of m.updated(k, v)", "2.13.0")
    def updated[V1 >: V](key: Long, value: V1): LongMap[V1] = {


  Map

    @deprecated("Use - or remove on an immutable Map", "2.13.0")
    def - (key: K): C = clone() -= key

    @deprecated("Use -- or removeAll on an immutable Map", "2.13.0")
    def - (key1: K, key2: K, keys: K*): C = clone() -= key1 -= key2 --= keys

    @deprecated("Use .filterInPlace instead of .retain", "2.13.0")
    def retain(p: (K, V) => Boolean): this.type = filterInPlace(p.tupled)

  Set

    @deprecated("Use .filterInPlace instead of .retain", "2.13.0")
    @`inline` final def retain(p: A => Boolean): this.type = filterInPlace(p)
  


scala.concurrent

  Future
    @deprecated("use Future.foldLeft instead", "2.12.0")
    def fold[T, R](futures: IterableOnce[Future[T]])(zero: R)(@deprecatedName('foldFun) op: (R, T) => R)(implicit executor: ExecutionContext): Future[R]

    @deprecated("use Future.reduceLeft instead", "2.12.0")
    def reduce[T, R >: T](futures: IterableOnce[Future[T]])(op: (R, T) => R)(implicit executor: ExecutionContext): Future[R] = {


scala.math

  @deprecated("This is an integer type; there is no reason to round it. Perhaps you meant to call this with a floating-point value?", "2.11.0")
  def round(x: Long): Long = x

  Ordering
    @deprecated("There are multiple ways to order Floats (Ordering.Float.TotalOrdering, " +
    "Ordering.Float.IeeeOrdering). Specify one by using a local import, assigning an implicit val, or passing it " +
    "explicitly. See the documentation for details.", since = "2.13.0")
    implicit object DeprecatedFloatOrdering extends Float.TotalOrdering

    @deprecated("There are multiple ways to order Doubles (Ordering.Double.TotalOrdering, " +
    "Ordering.Double.IeeeOrdering). Specify one by using a local import, assigning an implicit val, or passing it " +
    "explicitly. See the documentation for details.", since = "2.13.0")
    implicit object DeprecatedDoubleOrdering extends Double.TotalOrdering

scala.runtime

  RichInt
    @deprecated("this is an integer type; there is no reason to round it.  Perhaps you meant to call this on a floating-point value?", "2.11.0")
    def round: Int = self

  RichLong
    @deprecated("this is an integer type; there is no reason to round it.  Perhaps you meant to call this on a floating-point value?", "2.11.0")
    def round: Long = self

scala.sys.process

  ProcessBuilder

    @deprecated("use lazyLines", since = "2.13.0")
    def lineStream: Stream[String]

    @deprecated("use lazyLines", since = "2.13.0")
    def lineStream(capacity: Integer): Stream[String]

    @deprecated("use lazyLines", since = "2.13.0")
    def lineStream(log: ProcessLogger): Stream[String]

    @deprecated("use lazyLines", since = "2.13.0")
    def lineStream(log: ProcessLogger, capacity: Integer): Stream[String]

    @deprecated("use lazyLines_!", since = "2.13.0")
    def lineStream_! : Stream[String]

    @deprecated("use lazyLines_!", since = "2.13.0")
    def lineStream_!(capacity: Integer): Stream[String]

    @deprecated("use lazyLines_!", since = "2.13.0")
    def lineStream_!(log: ProcessLogger): Stream[String]

    @deprecated("use lazyLines_!", since = "2.13.0")
    def lineStream_!(log: ProcessLogger, capacity: Integer): Stream[String]


Predef

  @deprecated("Implicit conversions from Array to immutable.IndexedSeq are implemented by copying; Use the more efficient non-copying ArraySeq.unsafeWrapArray or an explicit toIndexedSeq call", "2.13.0")
  implicit def copyArrayToImmutableIndexedSeq[T](xs: Array[T]): IndexedSeq[T]