A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.scala-lang.org/api/2.12.18/scala/collection/immutable/Stream.html below:

Scala Standard Library 2.12.18 - scala.collection.immutable.Stream

sealed abstract class Stream[+A] extends AbstractSeq[A] with LinearSeq[A] with GenericTraversableTemplate[A, Stream] with LinearSeqOptimized[A, Stream[A]] with Serializable

 

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Stream
  2. Serializable
  3. Serializable
  4. LinearSeqOptimized
  5. LinearSeq
  6. LinearSeq
  7. LinearSeqLike
  8. Seq
  9. Iterable
  10. Traversable
  11. Immutable
  12. AbstractSeq
  13. Seq
  14. SeqLike
  15. GenSeq
  16. GenSeqLike
  17. PartialFunction
  18. Function1
  19. AbstractIterable
  20. Iterable
  21. IterableLike
  22. Equals
  23. GenIterable
  24. GenIterableLike
  25. AbstractTraversable
  26. Traversable
  27. GenTraversable
  28. GenericTraversableTemplate
  29. TraversableLike
  30. GenTraversableLike
  31. Parallelizable
  32. TraversableOnce
  33. GenTraversableOnce
  34. FilterMonadic
  35. HasNewBuilder
  36. AnyRef
  37. Any
Implicitly
  1. by CollectionsHaveToParArray
  2. by MonadOps
  3. by consWrapper
  4. by any2stringadd
  5. by StringFormat
  6. by Ensuring
  7. by ArrowAssoc
  8. by alternateImplicit
Abstract Value Members
  1.  abstract def tailDefined: Boolean
Concrete Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##(): Int
  3.  def #::[B >: A](hd: B): Stream[B]
  4.  def #:::[B >: A](prefix: Stream[B]): Stream[B]
  5.  def +(other: String): String
  6.  def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  7.  def ++:[B >: A, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  8.  def ++:[B](that: TraversableOnce[B]): Stream[B]
  9.  def +:(elem: A): Stream[A]
  10.  def ->[B](y: B): (Stream[A], B)
  11.  def :+(elem: A): Stream[A]
  12.  final def ==(arg0: Any): Boolean
  13.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder
  14.  def addString(b: StringBuilder): StringBuilder
  15.  def addString(b: StringBuilder, sep: String): StringBuilder
  16.  def aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B
  17.  def andThen[C](k: (A) ⇒ C): PartialFunction[Int, C]
  18.  def append[B >: A](rest: ⇒ TraversableOnce[B]): Stream[B]
  19.  def apply(n: Int): A
  20.  def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) ⇒ B1): B1
  21.  final def asInstanceOf[T0]: T0
  22.  def canEqual(that: Any): Boolean
  23.  def clone(): AnyRef
  24.  final def collect[B](pf: PartialFunction[A, B]): Stream[B]
  25.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
  26.  def combinations(n: Int): Iterator[Stream[A]]
  27.  def companion: GenericCompanion[Stream]
  28.  def compose[A](g: (A) ⇒ Int): (A) ⇒ A
  29.  def contains[A1 >: A](elem: A1): Boolean
  30.  def containsSlice[B](that: GenSeq[B]): Boolean
  31.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
  32.  def copyToArray(xs: Array[A]): Unit
  33.  def copyToArray(xs: Array[A], start: Int): Unit
  34.  def copyToBuffer[B >: A](dest: Buffer[B]): Unit
  35.  final def corresponds[B](that: GenSeq[B])(p: (A, B) ⇒ Boolean): Boolean
  36.  def count(p: (A) ⇒ Boolean): Int
  37.  def diff(that: collection.Seq[A]): Stream[A]
  38.  def distinct: Stream[A]
  39.  final def drop(n: Int): Stream[A]
  40.  def dropRight(n: Int): Stream[A]
  41.  def dropWhile(p: (A) ⇒ Boolean): Stream[A]
  42.  def endsWith[B](that: GenSeq[B]): Boolean
  43.  def ensuring(cond: (Stream[A]) ⇒ Boolean, msg: ⇒ Any): Stream[A]
  44.  def ensuring(cond: (Stream[A]) ⇒ Boolean): Stream[A]
  45.  def ensuring(cond: Boolean, msg: ⇒ Any): Stream[A]
  46.  def ensuring(cond: Boolean): Stream[A]
  47.  final def eq(arg0: AnyRef): Boolean
  48.  def equals(that: Any): Boolean
  49.  def exists(p: (A) ⇒ Boolean): Boolean
  50.  def filter(p: (A) ⇒ Boolean): Stream[A]
  51.  def filterNot(p: (A) ⇒ Boolean): Stream[A]
  52.  def finalize(): Unit
  53.  def find(p: (A) ⇒ Boolean): Option[A]
  54.  final def flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  55.  def flatten[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Stream[B]
  56.  def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
  57.  final def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
  58.  def foldRight[B](z: B)(op: (A, B) ⇒ B): B
  59.  def forall(p: (A) ⇒ Boolean): Boolean
  60.  def force: Stream[A]
  61.  final def foreach[U](f: (A) ⇒ U): Unit
  62.  def genericBuilder[B]: Builder[B, Stream[B]]
  63.  final def getClass(): Class[_]
  64.  def groupBy[K](f: (A) ⇒ K): Map[K, Stream[A]]
  65.  def grouped(size: Int): Iterator[Stream[A]]
  66.  def hasDefiniteSize: Boolean
  67.  def hashCode(): Int
  68.  def head: A
  69.  def headOption: Option[A]
  70.  def indexOf(elem: A, from: Int): Int
  71.  def indexOf(elem: A): Int
  72.  def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
  73.  def indexOfSlice[B >: A](that: GenSeq[B]): Int
  74.  def indexWhere(p: (A) ⇒ Boolean, from: Int): Int
  75.  def indexWhere(p: (A) ⇒ Boolean): Int
  76.  def indices: Range
  77.  def init: Stream[A]
  78.  def inits: Iterator[Stream[A]]
  79.  def intersect(that: collection.Seq[A]): Stream[A]
  80.  def isDefinedAt(x: Int): Boolean
  81.  def isEmpty: Boolean
  82.  final def isInstanceOf[T0]: Boolean
  83.  final def isTraversableAgain: Boolean
  84.  def iterator: Iterator[A]
  85.  def last: A
  86.  def lastIndexOf(elem: A, end: Int): Int
  87.  def lastIndexOf(elem: A): Int
  88.  def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
  89.  def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
  90.  def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int
  91.  def lastIndexWhere(p: (A) ⇒ Boolean): Int
  92.  def lastOption: Option[A]
  93.  def length: Int
  94.  def lengthCompare(len: Int): Int
  95.  def lift: (Int) ⇒ Option[A]
  96.  final def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  97.  def max: A
  98.  def maxBy[B](f: (A) ⇒ B): A
  99.  def min: A
  100.  def minBy[B](f: (A) ⇒ B): A
  101.  def mkString(start: String, sep: String, end: String): String
  102.  def mkString: String
  103.  def mkString(sep: String): String
  104.  final def ne(arg0: AnyRef): Boolean
  105.  def newBuilder: Builder[A, Stream[A]]
  106.  def nonEmpty: Boolean
  107.  final def notify(): Unit
  108.  final def notifyAll(): Unit
  109.  def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  110.  def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  111.  def par: ParSeq[A]
  112.  def parCombiner: Combiner[A, ParSeq[A]]
  113.  def partition(p: (A) ⇒ Boolean): (Stream[A], Stream[A])
  114.  def patch(from: Int, that: GenSeq[A], replaced: Int): Stream[A]
  115.  def permutations: Iterator[Stream[A]]
  116.  def prefixLength(p: (A) ⇒ Boolean): Int
  117.  def print(sep: String): Unit
  118.  def print(): Unit
  119.  def product: A
  120.  def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
  121.  final def reduceLeft[B >: A](f: (B, A) ⇒ B): B
  122.  def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
  123.  def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
  124.  def reduceRight[B >: A](op: (A, B) ⇒ B): B
  125.  def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
  126.  def repr: Stream[A]
  127.  def reverse: Stream[A]
  128.  def reverseIterator: Iterator[A]
  129.  def reverseMap[B](f: (A) ⇒ B): Stream[B]
  130.  def reversed: scala.List[A]
  131.  def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean
  132.  def sameElements(that: GenIterable[A]): Boolean
  133.  def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Stream[A], B, That]): That
  134.  final def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  135.  def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  136.  def segmentLength(p: (A) ⇒ Boolean, from: Int): Int
  137.  def seq: LinearSeq[A]
  138.  def size: Int
  139.  def sizeHintIfCheap: Int
  140.  def slice(from: Int, until: Int): Stream[A]
  141.  def sliding(size: Int, step: Int): Iterator[Stream[A]]
  142.  def sliding(size: Int): Iterator[Stream[A]]
  143.  def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): Stream[A]
  144.  def sortWith(lt: (A, A) ⇒ Boolean): Stream[A]
  145.  def sorted[B >: A](implicit ord: math.Ordering[B]): Stream[A]
  146.  def span(p: (A) ⇒ Boolean): (Stream[A], Stream[A])
  147.  def splitAt(n: Int): (Stream[A], Stream[A])
  148.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
  149.  def startsWith[B](that: GenSeq[B]): Boolean
  150.  def stringPrefix: String
  151.  def sum: A
  152.  final def synchronized[T0](arg0: ⇒ T0): T0
  153.  def tail: Stream[A]
  154.  def tails: Iterator[Stream[A]]
  155.  def take(n: Int): Stream[A]
  156.  def takeRight(n: Int): Stream[A]
  157.  def takeWhile(p: (A) ⇒ Boolean): Stream[A]
  158.  def thisCollection: collection.LinearSeq[A]
  159.  def to[Col[_]]: Col[A]
  160.  def toArray: Array[A]
  161.  def toBuffer[B >: A]: Buffer[B]
  162.  def toCollection(repr: Stream[A]): collection.LinearSeq[A]
  163.  def toIndexedSeq: IndexedSeq[A]
  164.  def toIterable: collection.Iterable[A]
  165.  def toIterator: Iterator[A]
  166.  def toList: scala.List[A]
  167.  def toMap[T, U]: collection.Map[T, U]
  168.  def toParArray: ParArray[T]
  169.  def toSeq: Seq[A]
  170.  def toSet[B >: A]: Set[B]
  171.  def toStream: Stream[A]
  172.  def toString(): String
  173.  def toTraversable: collection.Traversable[A]
  174.  def toVector: scala.Vector[A]
  175.  def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Stream[Stream[B]]
  176.  def union(that: collection.Seq[A]): Stream[A]
  177.  def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Stream[A1], Stream[A2])
  178.  def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Stream[A1], Stream[A2], Stream[A3])
  179.  def updated(index: Int, elem: A): Stream[A]
  180.  def view: StreamView[A, Stream[A]]
  181.  def view(from: Int, until: Int): SeqView[A, Stream[A]]
  182.  final def wait(): Unit
  183.  final def wait(arg0: Long, arg1: Int): Unit
  184.  final def wait(arg0: Long): Unit
  185.  final def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, Stream[A]]
  186.  final def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Stream[A], (A1, B), That]): That
  187.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Stream[(A, B)]
  188.  def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Stream[A], (A1, Int), That]): That
  189.  def →[B](y: B): (Stream[A], B)
Deprecated Value Members
  1.  def /:[B](z: B)(op: (B, A) ⇒ B): B
  2.  def :\[B](z: B)(op: (A, B) ⇒ B): B
  3.  def formatted(fmtstr: String): String

Inherited from java.io.Serializable

Inherited from (Int) ⇒ A Inherited from HasNewBuilder[A, scala.collection.immutable.Stream[A] @scala.annotation.unchecked.uncheckedVariance] Inherited by implicit conversion MonadOps from Stream[A] to MonadOps[A]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4