Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.scala-lang.org/api/2.12.19/scala/collection/mutable/ArrayOps$$ofInt.html below:

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

 

1. Alphabetic
2. By Inheritance

1. ofInt
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

1. by CollectionsHaveToParArray
2. by MonadOps
3. by any2stringadd
4. by StringFormat
5. by Ensuring
6. by ArrowAssoc
7. by alternateImplicit

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  def ++[B >: Int, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Array[Int], B, That]): That
5.  def ++:[B >: Int, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Array[Int], B, That]): That
6.  def ++:[B](that: TraversableOnce[B]): Array[B]
7.  def +:[B >: Int](elem: B)(implicit arg0: ClassTag[B]): Array[B]
8.  def +:(elem: A): Array[A]
9.  def ->[B](y: B): (ofInt, B)
10.  def :+[B >: Int](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, Int) ⇒ B, combop: (B, B) ⇒ B): B
17.  def apply(index: Int): Int
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[Int, B]): Option[B]
22.  def combinations(n: Int): Iterator[Array[Int]]
23.  def contains[A1 >: Int](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 >: Int](dest: Buffer[B]): Unit
29.  def corresponds[B](that: GenSeq[B])(p: (Int, B) ⇒ Boolean): Boolean
30.  def count(p: (Int) ⇒ Boolean): Int
31.  def deep: collection.IndexedSeq[Any]
32.  def diff(that: collection.Seq[Int]): Array[Int]
33.  def distinct: Array[Int]
34.  def drop(n: Int): Array[Int]
35.  def dropRight(n: Int): Array[Int]
36.  def dropWhile(p: (Int) ⇒ Boolean): Array[Int]
37.  def endsWith[B](that: GenSeq[B]): Boolean
38.  def ensuring(cond: (ofInt) ⇒ Boolean, msg: ⇒ Any): ofInt
39.  def ensuring(cond: (ofInt) ⇒ Boolean): ofInt
40.  def ensuring(cond: Boolean, msg: ⇒ Any): ofInt
41.  def ensuring(cond: Boolean): ofInt
42.  def exists(p: (Int) ⇒ Boolean): Boolean
43.  def filter(p: (Int) ⇒ Boolean): Array[Int]
44.  def filterNot(p: (Int) ⇒ Boolean): Array[Int]
45.  def find(p: (Int) ⇒ Boolean): Option[Int]
46.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Array[B]
47.  def flatten[U](implicit asTrav: (Int) ⇒ collection.Traversable[U], m: ClassTag[U]): Array[U]
48.  def fold[A1 >: Int](z: A1)(op: (A1, A1) ⇒ A1): A1
49.  def foldLeft[B](z: B)(op: (B, Int) ⇒ B): B
50.  def foldRight[B](z: B)(op: (Int, B) ⇒ B): B
51.  def forall(p: (Int) ⇒ Boolean): Boolean
52.  def foreach(f: (A) ⇒ Unit): Unit
53.  def getClass(): Class[_ <: AnyVal]
54.  def groupBy[K](f: (Int) ⇒ K): immutable.Map[K, Array[Int]]
55.  def grouped(size: Int): Iterator[Array[Int]]
56.  def hasDefiniteSize: Boolean
57.  def head: Int
58.  def headOption: Option[Int]
59.  def indexOf(elem: Int, from: Int): Int
60.  def indexOf(elem: Int): Int
61.  def indexOfSlice[B >: Int](that: GenSeq[B], from: Int): Int
62.  def indexOfSlice[B >: Int](that: GenSeq[B]): Int
63.  def indexWhere(p: (Int) ⇒ Boolean, from: Int): Int
64.  def indexWhere(p: (Int) ⇒ Boolean): Int
65.  def indices: immutable.Range
66.  def init: Array[Int]
67.  def inits: Iterator[Array[Int]]
68.  def intersect(that: collection.Seq[Int]): Array[Int]
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[Int]
74.  def last: Int
75.  def lastIndexOf(elem: Int, end: Int): Int
76.  def lastIndexOf(elem: Int): Int
77.  def lastIndexOfSlice[B >: Int](that: GenSeq[B], end: Int): Int
78.  def lastIndexOfSlice[B >: Int](that: GenSeq[B]): Int
79.  def lastIndexWhere(p: (Int) ⇒ Boolean, end: Int): Int
80.  def lastIndexWhere(p: (Int) ⇒ Boolean): Int
81.  def lastOption: Option[Int]
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.ofInt
93.  def nonEmpty: Boolean
94.  def padTo(len: Int, elem: A): Array[A]
95.  def par: ParArray[Int]
96.  def parCombiner: Combiner[Int, ParArray[Int]]
97.  def partition(p: (Int) ⇒ Boolean): (Array[Int], Array[Int])
98.  def patch(from: Int, that: GenSeq[A], replaced: Int): Array[A]
99.  def permutations: Iterator[Array[Int]]
100.  def prefixLength(p: (Int) ⇒ Boolean): Int
101.  def product: A
102.  def reduce[A1 >: Int](op: (A1, A1) ⇒ A1): A1
103.  def reduceLeft[B >: Int](op: (B, Int) ⇒ B): B
104.  def reduceLeftOption[B >: Int](op: (B, Int) ⇒ B): Option[B]
105.  def reduceOption[A1 >: Int](op: (A1, A1) ⇒ A1): Option[A1]
106.  def reduceRight[B >: Int](op: (Int, B) ⇒ B): B
107.  def reduceRightOption[B >: Int](op: (Int, B) ⇒ B): Option[B]
108.  val repr: Array[Int]
109.  def reverse: Array[Int]
110.  def reverseIterator: Iterator[Int]
111.  def reverseMap[B](f: (A) ⇒ B): Array[B]
112.  def reversed: List[Int]
113.  def sameElements(that: GenIterable[A]): Boolean
114.  def scan[B >: Int, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Array[Int], B, That]): That
115.  def scanLeft[B, That](z: B)(op: (B, Int) ⇒ B)(implicit bf: CanBuildFrom[Array[Int], B, That]): That
116.  def scanRight[B, That](z: B)(op: (Int, B) ⇒ B)(implicit bf: CanBuildFrom[Array[Int], B, That]): That
117.  def segmentLength(p: (Int) ⇒ Boolean, from: Int): Int
118.  def seq: IndexedSeq[Int]
119.  def size: Int
120.  def sizeHintIfCheap: Int
121.  def slice(from: Int, until: Int): Array[Int]
122.  def sliding(size: Int, step: Int): Iterator[Array[Int]]
123.  def sliding(size: Int): Iterator[Array[Int]]
124.  def sortBy[B](f: (Int) ⇒ B)(implicit ord: math.Ordering[B]): Array[Int]
125.  def sortWith(lt: (Int, Int) ⇒ Boolean): Array[Int]
126.  def sorted[B >: Int](implicit ord: math.Ordering[B]): Array[Int]
127.  def span(p: (Int) ⇒ Boolean): (Array[Int], Array[Int])
128.  def splitAt(n: Int): (Array[Int], Array[Int])
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[Int]
134.  def tails: Iterator[Array[Int]]
135.  def take(n: Int): Array[Int]
136.  def takeRight(n: Int): Array[Int]
137.  def takeWhile(p: (Int) ⇒ Boolean): Array[Int]
138.  def thisCollection: WrappedArray[Int]
139.  def to[Col[_]]: Col[A]
140.  def toArray: Array[A]
141.  def toBuffer[A1 >: Int]: Buffer[A1]
142.  def toCollection(repr: Array[Int]): WrappedArray[Int]
143.  def toIndexedSeq: immutable.IndexedSeq[Int]
144.  def toIterable: collection.Iterable[Int]
145.  def toIterator: Iterator[Int]
146.  def toList: List[Int]
147.  def toMap[T, U]: collection.Map[T, U]
148.  def toParArray: ParArray[T]
149.  def toSeq: collection.Seq[Int]
150.  def toSet[B >: Int]: immutable.Set[B]
151.  def toStream: immutable.Stream[Int]
152.  def toString(): String
153.  def toTraversable: collection.Traversable[Int]
154.  def toVector: Vector[Int]
155.  def transpose[U](implicit asArray: (Int) ⇒ Array[U]): Array[Array[U]]
156.  def union(that: collection.Seq[Int]): Array[Int]
157.  def unzip[T1, T2](implicit asPair: (Int) ⇒ (T1, T2), ct1: ClassTag[T1], ct2: ClassTag[T2]): (Array[T1], Array[T2])
158.  def unzip3[T1, T2, T3](implicit asTriple: (Int) ⇒ (T1, T2, T3), ct1: ClassTag[T1], ct2: ClassTag[T2], ct3: ClassTag[T3]): (Array[T1], Array[T2], Array[T3])
159.  def update(index: Int, elem: Int): Unit
160.  def updated(index: Int, elem: A): Array[A]
161.  def view(from: Int, until: Int): IndexedSeqView[Int, Array[Int]]
162.  def view: IndexedSeqView[Int, Array[Int]]
163.  def withFilter(p: (Int) ⇒ Boolean): FilterMonadic[Int, Array[Int]]
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): (ofInt, B)

1.  def /:[B](z: B)(op: (B, Int) ⇒ B): B
2.  def :\[B](z: B)(op: (Int, 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