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/ArrayOps$$ofUnit.html below:

Scala Standard Library 2.12.19 - scala.collection.mutable.ArrayOps.ofUnit

final class ofUnit extends AnyVal with ArrayOps[Unit] with ArrayLike[Unit, Array[Unit]]

 

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