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/mutable/IndexedSeqView.html below:

Scala Standard Library 2.12.15 - scala.collection.mutable.IndexedSeqView

trait IndexedSeqView[A, +Coll] extends IndexedSeq[A] with IndexedSeqOptimized[A, IndexedSeqView[A, Coll]] with SeqView[A, Coll] with SeqViewLike[A, Coll, IndexedSeqView[A, Coll]]

 

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. IndexedSeqView
  2. SeqView
  3. SeqViewLike
  4. IterableView
  5. IterableViewLike
  6. TraversableView
  7. TraversableViewLike
  8. ViewMkString
  9. IndexedSeqOptimized
  10. IndexedSeqOptimized
  11. IndexedSeq
  12. IndexedSeqLike
  13. IndexedSeq
  14. IndexedSeqLike
  15. Seq
  16. SeqLike
  17. Cloneable
  18. Cloneable
  19. Cloneable
  20. Seq
  21. SeqLike
  22. GenSeq
  23. GenSeqLike
  24. PartialFunction
  25. Function1
  26. Iterable
  27. Iterable
  28. IterableLike
  29. Equals
  30. GenIterable
  31. GenIterableLike
  32. Traversable
  33. Mutable
  34. Traversable
  35. GenTraversable
  36. GenericTraversableTemplate
  37. TraversableLike
  38. GenTraversableLike
  39. Parallelizable
  40. TraversableOnce
  41. GenTraversableOnce
  42. FilterMonadic
  43. HasNewBuilder
  44. AnyRef
  45. 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
  3.  abstract def underlying: Coll
  4.  abstract def update(idx: Int, elem: A): Unit
Concrete Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##(): Int
  3.  def +(other: String): String
  4.  def ++[B >: A, That](xs: GenTraversableOnce[B])(implicit bf: CanBuildFrom[IndexedSeqView[A, Coll], B, That]): That
  5.  def ++:[B >: A, That](xs: collection.Traversable[B])(implicit bf: CanBuildFrom[IndexedSeqView[A, Coll], B, That]): That
  6.  def ++:[B](that: TraversableOnce[B]): IndexedSeq[B]
  7.  def +:(elem: A): IndexedSeq[A]
  8.  def ->[B](y: B): (IndexedSeqView[A, Coll], B)
  9.  def :+(elem: A): IndexedSeq[A]
  10.  final def ==(arg0: Any): Boolean
  11.  def addString(b: scala.StringBuilder, start: String, sep: String, end: String): scala.StringBuilder
  12.  def addString(b: scala.StringBuilder): scala.StringBuilder
  13.  def addString(b: scala.StringBuilder, sep: String): scala.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(): Seq[A]
  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[IndexedSeqView[A, Coll]]
  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: IndexedSeqView[A, Coll]
  35.  def drop(n: Int): This
  36.  def dropRight(n: Int): IndexedSeqView[A, Coll]
  37.  def dropWhile(p: (A) ⇒ Boolean): This
  38.  def endsWith[B](that: GenSeq[B]): Boolean
  39.  def ensuring(cond: (IndexedSeqView[A, Coll]) ⇒ Boolean, msg: ⇒ Any): IndexedSeqView[A, Coll]
  40.  def ensuring(cond: (IndexedSeqView[A, Coll]) ⇒ Boolean): IndexedSeqView[A, Coll]
  41.  def ensuring(cond: Boolean, msg: ⇒ Any): IndexedSeqView[A, Coll]
  42.  def ensuring(cond: Boolean): IndexedSeqView[A, Coll]
  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): This
  47.  def filterNot(p: (A) ⇒ Boolean): IndexedSeqView[A, Coll]
  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 force[B >: A, That](implicit bf: CanBuildFrom[Coll, B, That]): That
  57.  def foreach(f: (A) ⇒ Unit): Unit
  58.  def formatted(fmtstr: String): String
  59.  def genericBuilder[B]: Builder[B, IndexedSeq[B]]
  60.  final def getClass(): Class[_]
  61.  def groupBy[K](f: (A) ⇒ K): immutable.Map[K, IndexedSeqView[A, Coll]]
  62.  def grouped(size: Int): Iterator[IndexedSeqView[A, Coll]]
  63.  def hasDefiniteSize: Boolean
  64.  def hashCode(): Int
  65.  def head: A
  66.  def headOption: Option[A]
  67.  def indexOf(elem: A, from: Int): Int
  68.  def indexOf(elem: A): Int
  69.  def indexOfSlice[B >: A](that: GenSeq[B], from: Int): Int
  70.  def indexOfSlice[B >: A](that: GenSeq[B]): Int
  71.  def indexWhere(p: (A) ⇒ Boolean, from: Int): Int
  72.  def indexWhere(p: (A) ⇒ Boolean): Int
  73.  def indices: immutable.Range
  74.  def init: This
  75.  def inits: Iterator[IndexedSeqView[A, Coll]]
  76.  def intersect(that: collection.Seq[A]): IndexedSeq[A]
  77.  def isDefinedAt(idx: Int): Boolean
  78.  def isEmpty: Boolean
  79.  final def isInstanceOf[T0]: Boolean
  80.  final def isTraversableAgain: Boolean
  81.  def iterator: Iterator[A]
  82.  def last: A
  83.  def lastIndexOf(elem: A, end: Int): Int
  84.  def lastIndexOf(elem: A): Int
  85.  def lastIndexOfSlice[B >: A](that: GenSeq[B], end: Int): Int
  86.  def lastIndexOfSlice[B >: A](that: GenSeq[B]): Int
  87.  def lastIndexWhere(p: (A) ⇒ Boolean, end: Int): Int
  88.  def lastIndexWhere(p: (A) ⇒ Boolean): Int
  89.  def lastOption: Option[A]
  90.  def lengthCompare(len: Int): Int
  91.  def lift: (Int) ⇒ Option[A]
  92.  def map[B](f: (A) ⇒ B): IndexedSeq[B]
  93.  def max: A
  94.  def maxBy[B](f: (A) ⇒ B): A
  95.  def min: A
  96.  def minBy[B](f: (A) ⇒ B): A
  97.  def mkString(start: String, sep: String, end: String): String
  98.  def mkString(sep: String): String
  99.  def mkString: String
  100.  final def ne(arg0: AnyRef): Boolean
  101.  def newAppended[B >: A](that: GenTraversable[B]): IndexedSeqView.Transformed[B]
  102.  def newBuilder: Builder[A, IndexedSeqView[A, Coll]]
  103.  def newDropped(n: Int): IndexedSeqView.Transformed[A]
  104.  def newDroppedWhile(p: (A) ⇒ Boolean): Transformed[A]
  105.  def newFiltered(p: (A) ⇒ Boolean): Transformed[A]
  106.  def newFlatMapped[B](f: (A) ⇒ GenTraversableOnce[B]): IndexedSeqView.Transformed[B]
  107.  def newForced[B](xs: ⇒ GenSeq[B]): IndexedSeqView.Transformed[B]
  108.  def newMapped[B](f: (A) ⇒ B): IndexedSeqView.Transformed[B]
  109.  def newPatched[B >: A](_from: Int, _patch: GenSeq[B], _replaced: Int): IndexedSeqView.Transformed[B]
  110.  def newPrepended[B >: A](that: GenTraversable[B]): IndexedSeqView.Transformed[B]
  111.  def newReversed: Transformed[A]
  112.  def newSliced(_endpoints: SliceInterval): Transformed[A]
  113.  def newTaken(n: Int): IndexedSeqView.Transformed[A]
  114.  def newTakenWhile(p: (A) ⇒ Boolean): Transformed[A]
  115.  def newZipped[B](that: GenIterable[B]): IndexedSeqView.Transformed[(A, B)]
  116.  def newZippedAll[A1 >: A, B](that: GenIterable[B], _thisElem: A1, _thatElem: B): IndexedSeqView.Transformed[(A1, B)]
  117.  def nonEmpty: Boolean
  118.  final def notify(): Unit
  119.  final def notifyAll(): Unit
  120.  def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  121.  def padTo(len: Int, elem: A): IndexedSeq[A]
  122.  def par: ParSeq[A]
  123.  def parCombiner: Combiner[A, ParSeq[A]]
  124.  def partition(p: (A) ⇒ Boolean): (IndexedSeqView[A, Coll], IndexedSeqView[A, Coll])
  125.  def patch(from: Int, that: GenSeq[A], replaced: Int): IndexedSeq[A]
  126.  def permutations: Iterator[IndexedSeqView[A, Coll]]
  127.  def prefixLength(p: (A) ⇒ Boolean): Int
  128.  def product: A
  129.  def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
  130.  def reduceLeft[B >: A](op: (B, A) ⇒ B): B
  131.  def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
  132.  def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
  133.  def reduceRight[B >: A](op: (A, B) ⇒ B): B
  134.  def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
  135.  def repr: IndexedSeqView[A, Coll]
  136.  def reverse: This
  137.  def reverseIterator: Iterator[A]
  138.  def reverseMap[B](f: (A) ⇒ B): IndexedSeq[B]
  139.  def reversed: List[A]
  140.  def runWith[U](action: (A) ⇒ U): (Int) ⇒ Boolean
  141.  def sameElements(that: GenIterable[A]): Boolean
  142.  def scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[IndexedSeqView[A, Coll], B, That]): That
  143.  def scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeqView[A, Coll], B, That]): That
  144.  def scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[IndexedSeqView[A, Coll], B, That]): That
  145.  def segmentLength(p: (A) ⇒ Boolean, from: Int): Int
  146.  def seq: IndexedSeq[A]
  147.  def size: Int
  148.  def sizeHintIfCheap: Int
  149.  def slice(from: Int, until: Int): This
  150.  def sliding(size: Int): Iterator[IndexedSeqView[A, Coll]]
  151.  def sliding(size: Int, step: Int): Iterator[IndexedSeqView[A, Coll]]
  152.  def sortBy[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): IndexedSeqView[A, Coll]
  153.  def sortWith(lt: (A, A) ⇒ Boolean): IndexedSeqView[A, Coll]
  154.  def sorted[B >: A](implicit ord: Ordering[B]): IndexedSeqView[A, Coll]
  155.  def span(p: (A) ⇒ Boolean): (This, This)
  156.  def splitAt(n: Int): (This, This)
  157.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
  158.  def startsWith[B](that: GenSeq[B]): Boolean
  159.  def stringPrefix: String
  160.  def sum: A
  161.  final def synchronized[T0](arg0: ⇒ T0): T0
  162.  def tail: IndexedSeqView[A, Coll]
  163.  def tails: Iterator[IndexedSeqView[A, Coll]]
  164.  def take(n: Int): This
  165.  def takeRight(n: Int): IndexedSeqView[A, Coll]
  166.  def takeWhile(p: (A) ⇒ Boolean): This
  167.  def thisCollection: IndexedSeq[A]
  168.  def thisSeq: collection.Seq[A]
  169.  def to[Col[_]]: Col[A]
  170.  def toArray: Array[A]
  171.  def toBuffer[A1 >: A]: Buffer[A1]
  172.  def toCollection(repr: IndexedSeqView[A, Coll]): IndexedSeq[A]
  173.  def toIndexedSeq: immutable.IndexedSeq[A]
  174.  def toIterable: collection.Iterable[A]
  175.  def toIterator: Iterator[A]
  176.  def toList: List[A]
  177.  def toMap[T, U]: collection.Map[T, U]
  178.  def toParArray: ParArray[T]
  179.  def toSeq: collection.Seq[A]
  180.  def toSet[B >: A]: immutable.Set[B]
  181.  def toStream: immutable.Stream[A]
  182.  def toString(): String
  183.  def toTraversable: collection.Traversable[A]
  184.  def toVector: Vector[A]
  185.  def transform(f: (A) ⇒ A): IndexedSeqView.this.type
  186.  def transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): IndexedSeq[IndexedSeq[B]]
  187.  def union(that: collection.Seq[A]): IndexedSeq[A]
  188.  def unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (IndexedSeqView.Transformed[A1], IndexedSeqView.Transformed[A2])
  189.  def unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (IndexedSeqView.Transformed[A1], IndexedSeqView.Transformed[A2], IndexedSeqView.Transformed[A3])
  190.  def updated(index: Int, elem: A): IndexedSeq[A]
  191.  def view(from: Int, until: Int): IndexedSeqView[A, IndexedSeqView[A, Coll]]
  192.  def view: IndexedSeqView[A, IndexedSeqView[A, Coll]]
  193.  def viewIdString: String
  194.  def viewIdentifier: String
  195.  def viewToString: String
  196.  final def wait(): Unit
  197.  final def wait(arg0: Long, arg1: Int): Unit
  198.  final def wait(arg0: Long): Unit
  199.  def withFilter(p: (A) ⇒ Boolean): IndexedSeqView[A, Coll]
  200.  def zip[B](that: GenIterable[B]): IndexedSeq[(A, B)]
  201.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): IndexedSeq[(A, B)]
  202.  def zipWithIndex: IndexedSeq[(A, Int)]
  203.  def →[B](y: B): (IndexedSeqView[A, Coll], 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.lang.Cloneable

Inherited from (Int) ⇒ 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