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

Scala Standard Library 2.12.19 - scala.collection.immutable.IndexedSeq

trait IndexedSeq[+A] extends Seq[A] with collection.IndexedSeq[A] with GenericTraversableTemplate[A, IndexedSeq] with IndexedSeqLike[A, IndexedSeq[A]]

 

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

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