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

Scala Standard Library 2.12.19 - scala.collection.mutable.ArrayLike

trait ArrayLike[A, +Repr] extends IndexedSeqOptimized[A, Repr]

 

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

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