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.15/scala/collection/immutable/Stream.html below:

Scala Standard Library 2.12.15 - 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 formatted(fmtstr: String): String
  63.  def genericBuilder[B]: Builder[B, Stream[B]]
  64.  final def getClass(): Class[_]
  65.  def groupBy[K](f: (A) ⇒ K): Map[K, Stream[A]]
  66.  def grouped(size: Int): Iterator[Stream[A]]
  67.  def hasDefiniteSize: Boolean
  68.  def hashCode(): Int
  69.  def head: A
  70.  def headOption: Option[A]
  71.  def indexOf(elem: A, from: Int): Int
  72.  def indexOf(elem: A): Int
  73.  def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
  74.  def indexOfSlice[B >: A](that: GenSeq[B]): Int
  75.  def indexWhere(p: (A) ⇒ Boolean, from: Int): Int
  76.  def indexWhere(p: (A) ⇒ Boolean): Int
  77.  def indices: Range
  78.  def init: Stream[A]
  79.  def inits: Iterator[Stream[A]]
  80.  def intersect(that: collection.Seq[A]): Stream[A]
  81.  def isDefinedAt(x: Int): Boolean
  82.  def isEmpty: Boolean
  83.  final def isInstanceOf[T0]: Boolean
  84.  final def isTraversableAgain: Boolean
  85.  def iterator: Iterator[A]
  86.  def last: A
  87.  def lastIndexOf(elem: A, end: Int): Int
  88.  def lastIndexOf(elem: A): Int
  89.  def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
  90.  def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
  91.  def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int
  92.  def lastIndexWhere(p: (A) ⇒ Boolean): Int
  93.  def lastOption: Option[A]
  94.  def length: Int
  95.  def lengthCompare(len: Int): Int
  96.  def lift: (Int) ⇒ Option[A]
  97.  final def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  98.  def max: A
  99.  def maxBy[B](f: (A) ⇒ B): A
  100.  def min: A
  101.  def minBy[B](f: (A) ⇒ B): A
  102.  def mkString(start: String, sep: String, end: String): String
  103.  def mkString: String
  104.  def mkString(sep: String): String
  105.  final def ne(arg0: AnyRef): Boolean
  106.  def newBuilder: Builder[A, Stream[A]]
  107.  def nonEmpty: Boolean
  108.  final def notify(): Unit
  109.  final def notifyAll(): Unit
  110.  def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  111.  def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  112.  def par: ParSeq[A]
  113.  def parCombiner: Combiner[A, ParSeq[A]]
  114.  def partition(p: (A) ⇒ Boolean): (Stream[A], Stream[A])
  115.  def patch(from: Int, that: GenSeq[A], replaced: Int): Stream[A]
  116.  def permutations: Iterator[Stream[A]]
  117.  def prefixLength(p: (A) ⇒ Boolean): Int
  118.  def print(sep: String): Unit
  119.  def print(): Unit
  120.  def product: A
  121.  def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
  122.  final def reduceLeft[B >: A](f: (B, A) ⇒ B): B
  123.  def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
  124.  def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
  125.  def reduceRight[B >: A](op: (A, B) ⇒ B): B
  126.  def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
  127.  def repr: Stream[A]
  128.  def reverse: Stream[A]
  129.  def reverseIterator: Iterator[A]
  130.  def reverseMap[B](f: (A) ⇒ B): Stream[B]
  131.  def reversed: scala.List[A]
  132.  def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean
  133.  def sameElements(that: GenIterable[A]): Boolean
  134.  def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Stream[A], B, That]): That
  135.  final def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  136.  def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That
  137.  def segmentLength(p: (A) ⇒ Boolean, from: Int): Int
  138.  def seq: LinearSeq[A]
  139.  def size: Int
  140.  def sizeHintIfCheap: Int
  141.  def slice(from: Int, until: Int): Stream[A]
  142.  def sliding(size: Int, step: Int): Iterator[Stream[A]]
  143.  def sliding(size: Int): Iterator[Stream[A]]
  144.  def sortBy[B](f: (A) ⇒ B)(implicit ord: math.Ordering[B]): Stream[A]
  145.  def sortWith(lt: (A, A) ⇒ Boolean): Stream[A]
  146.  def sorted[B >: A](implicit ord: math.Ordering[B]): Stream[A]
  147.  def span(p: (A) ⇒ Boolean): (Stream[A], Stream[A])
  148.  def splitAt(n: Int): (Stream[A], Stream[A])
  149.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
  150.  def startsWith[B](that: GenSeq[B]): Boolean
  151.  def stringPrefix: String
  152.  def sum: A
  153.  final def synchronized[T0](arg0: ⇒ T0): T0
  154.  def tail: Stream[A]
  155.  def tails: Iterator[Stream[A]]
  156.  def take(n: Int): Stream[A]
  157.  def takeRight(n: Int): Stream[A]
  158.  def takeWhile(p: (A) ⇒ Boolean): Stream[A]
  159.  def thisCollection: collection.LinearSeq[A]
  160.  def to[Col[_]]: Col[A]
  161.  def toArray: Array[A]
  162.  def toBuffer[B >: A]: Buffer[B]
  163.  def toCollection(repr: Stream[A]): collection.LinearSeq[A]
  164.  def toIndexedSeq: IndexedSeq[A]
  165.  def toIterable: collection.Iterable[A]
  166.  def toIterator: Iterator[A]
  167.  def toList: scala.List[A]
  168.  def toMap[T, U]: collection.Map[T, U]
  169.  def toParArray: ParArray[T]
  170.  def toSeq: Seq[A]
  171.  def toSet[B >: A]: Set[B]
  172.  def toStream: Stream[A]
  173.  def toString(): String
  174.  def toTraversable: collection.Traversable[A]
  175.  def toVector: scala.Vector[A]
  176.  def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): Stream[Stream[B]]
  177.  def union(that: collection.Seq[A]): Stream[A]
  178.  def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (Stream[A1], Stream[A2])
  179.  def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (Stream[A1], Stream[A2], Stream[A3])
  180.  def updated(index: Int, elem: A): Stream[A]
  181.  def view: StreamView[A, Stream[A]]
  182.  def view(from: Int, until: Int): SeqView[A, Stream[A]]
  183.  final def wait(): Unit
  184.  final def wait(arg0: Long, arg1: Int): Unit
  185.  final def wait(arg0: Long): Unit
  186.  final def withFilter(p: (A) ⇒ Boolean): FilterMonadic[A, Stream[A]]
  187.  final def zip[A1 >: A, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Stream[A], (A1, B), That]): That
  188.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Stream[(A, B)]
  189.  def zipWithIndex[A1 >: A, That](implicit bf: CanBuildFrom[Stream[A], (A1, Int), That]): That
  190.  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

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