Scala Standard Library 2.13.1 - scala.Array (original) (raw)

final class Array[T] extends java.io.Serializable with java.lang.Cloneable

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. Array
2. Cloneable
3. Serializable
4. AnyRef
5. Any

Implicitly

1. by genericArrayOps

2. by ArrayCharSequence

3. by copyArrayToImmutableIndexedSeq

4. by any2stringadd

5. by StringFormat

6. by Ensuring

7. by ArrowAssoc

8. Hide All

9. Show All

Visibility

1. Public
2. Protected

Instance Constructors

1.  new Array(_length: Int)

Value Members

1.  final def !=(arg0: Any): Boolean
2.  final def ##(): Int
3.  def +(other: String): String
4.  final def ++[B >: A](xs: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
5.  final def ++[B >: A](xs: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
6.  final def ++[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
7.  final def ++:[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
8.  final def ++:[B >: A](prefix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
9.  final def ++:[B >: A](prefix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
10.  final def +:[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
11.  final def +:[B >: A](elem: B): collection.immutable.IndexedSeq[B]
12.  def ->[B](y: B): (Array[T], B)
13.  final def :+[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
14.  final def :+[B >: A](elem: B): collection.immutable.IndexedSeq[B]
15.  final def :++[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
16.  final def :++[B >: A](suffix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
17.  final def :++[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
18.  final def ==(arg0: Any): Boolean
19.  final def addString(b: collection.mutable.StringBuilder): collection.mutable.StringBuilder
20.  final def addString(b: collection.mutable.StringBuilder, sep: String): collection.mutable.StringBuilder
21.  def addString(b: collection.mutable.StringBuilder, start: String, sep: String, end: String): collection.mutable.StringBuilder
22.  def andThen[C](k: PartialFunction[T, C]): PartialFunction[Int, C]
23.  def andThen[C](k: (T) => C): PartialFunction[Int, C]
24.  def appended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
25.  def appended[B >: A](elem: B): collection.immutable.IndexedSeq[B]
26.  def appendedAll[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
27.  def appendedAll[B >: A](suffix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
28.  def appendedAll[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
29.  def apply(i: Int): T
30.  def applyOrElse[A1 <: A, B1 >: B](x: A1, default: (A1) => B1): B1
31.  final def asInstanceOf[T0]: T0
32.  def canEqual(that: Any): Boolean
33.  def charAt(index: Int): Char
34.  def chars(): IntStream
35.  def clone(): Array[T]
36.  def codePoints(): IntStream
37.  def collect[B](pf: PartialFunction[T, B])(implicit arg0: ClassTag[B]): Array[B]
38.  def collect[B](pf: PartialFunction[T, B]): collection.immutable.IndexedSeq[B]
39.  def collectFirst[B](f: PartialFunction[T, B]): Option[B]
40.  def collectFirst[B](pf: PartialFunction[T, B]): Option[B]
41.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, T]
42.  def compose[A](g: (A) => Int): (A) => T
43.  final def concat[B >: A](suffix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
44.  final def concat[B >: A](suffix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
45.  final def concat[B >: A](suffix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
46.  def containsSlice[B](that: collection.Seq[B]): Boolean
47.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
48.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
49.  def copyToArray[B >: A](xs: Array[B]): Int
50.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
51.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
52.  def copyToArray[B >: A](xs: Array[B]): Int
53.  def corresponds[B](that: collection.Seq[B])(p: (T, B) => Boolean): Boolean
54.  def corresponds[B](that: collection.IterableOnce[B])(p: (T, B) => Boolean): Boolean
55.  def diff[B >: A](that: collection.Seq[B]): Array[T]
56.  def diff[B >: A](that: collection.Seq[B]): collection.immutable.IndexedSeq[T]
57.  def distinctBy[B](f: (T) => B): Array[T]
58.  def distinctBy[B](f: (T) => B): collection.immutable.IndexedSeq[T]
59.  def elementWise: ElementWiseExtractor[Int, T]
60.  def empty: collection.immutable.IndexedSeq[T]
61.  def endsWith[B >: A](that: collection.Iterable[B]): Boolean
62.  def endsWith[B >: A](that: Array[B]): Boolean
63.  def endsWith[B >: A](that: collection.Iterable[B]): Boolean
64.  def ensuring(cond: (Array[T]) => Boolean, msg: => Any): Array[T]
65.  def ensuring(cond: (Array[T]) => Boolean): Array[T]
66.  def ensuring(cond: Boolean, msg: => Any): Array[T]
67.  def ensuring(cond: Boolean): Array[T]
68.  final def eq(arg0: AnyRef): Boolean
69.  def equals(arg0: AnyRef): Boolean
70.  def finalize(): Unit
71.  def findLast(p: (T) => Boolean): Option[T]
72.  def flatMap[BS, B](f: (T) => BS)(implicit asIterable: (BS) => collection.Iterable[B], m: ClassTag[B]): Array[B]
73.  def flatMap[B](f: (T) => collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
74.  def flatMap[B](f: (T) => collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
75.  def flatten[B](implicit asIterable: (T) => collection.IterableOnce[B], m: ClassTag[B]): Array[B]
76.  def flatten[B](implicit asIterable: (T) => collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
77.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
78.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
79.  def foldLeft[B](z: B)(op: (B, T) => B): B
80.  def foldLeft[B](z: B)(op: (B, T) => B): B
81.  def foldRight[B](z: B)(op: (T, B) => B): B
82.  def foldRight[B](z: B)(op: (T, B) => B): B
83.  def foreach[U](f: (T) => U): Unit
84.  def foreach[U](f: (T) => U): Unit
85.  def formatted(fmtstr: String): String
86.  final def getClass(): Class[_ <: AnyRef]
87.  def groupBy[K](f: (T) => K): Map[K, Array[T]]
88.  def groupBy[K](f: (T) => K): Map[K, collection.immutable.IndexedSeq[T]]
89.  def groupMap[K, B](key: (T) => K)(f: (T) => B)(implicit arg0: ClassTag[B]): Map[K, Array[B]]
90.  def groupMap[K, B](key: (T) => K)(f: (T) => B): Map[K, collection.immutable.IndexedSeq[B]]
91.  def groupMapReduce[K, B](key: (T) => K)(f: (T) => B)(reduce: (B, B) => B): Map[K, B]
92.  def hashCode(): Int
93.  def indexOf[B >: A](elem: B): Int
94.  def indexOfSlice[B >: A](that: collection.Seq[B]): Int
95.  def indexOfSlice[B >: A](that: collection.Seq[B], from: Int): Int
96.  def indexWhere(p: (T) => Boolean): Int
97.  def intersect[B >: A](that: collection.Seq[B]): Array[T]
98.  def intersect[B >: A](that: collection.Seq[B]): collection.immutable.IndexedSeq[T]
99.  def isDefinedAt(idx: Int): Boolean
100.  final def isInstanceOf[T0]: Boolean
101.  def isTraversableAgain: Boolean
102.  def iterableFactory: SeqFactory[collection.immutable.IndexedSeq]
103.  def lastIndexOfSlice[B >: A](that: collection.Seq[B]): Int
104.  def lastIndexOfSlice[B >: A](that: collection.Seq[B], end: Int): Int
105.  def lastIndexWhere(p: (T) => Boolean): Int
106.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[T, B, Array[T]]
107.  def lazyZip[B]: ([B](that: Iterable[B])scala.collection.LazyZip2[T,B,_1.type]) forSome {val _1: collection.immutable.IndexedSeq[T]}
108.  def length: Int
109.  final def lengthCompare(that: collection.Iterable[_]): Int
110.  def lift: (Int) => Option[T]
111.  def map[B](f: (T) => B)(implicit ct: ClassTag[B]): Array[B]
112.  def map[B](f: (T) => B): collection.immutable.IndexedSeq[B]
113.  def mapInPlace(f: (T) => T): Array[T]
114.  def max[B >: A](implicit ord: math.Ordering[B]): T
115.  def maxBy[B](f: (T) => B)(implicit cmp: math.Ordering[B]): T
116.  def maxByOption[B](f: (T) => B)(implicit cmp: math.Ordering[B]): Option[T]
117.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[T]
118.  def min[B >: A](implicit ord: math.Ordering[B]): T
119.  def minBy[B](f: (T) => B)(implicit cmp: math.Ordering[B]): T
120.  def minByOption[B](f: (T) => B)(implicit cmp: math.Ordering[B]): Option[T]
121.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[T]
122.  final def mkString: String
123.  final def mkString(sep: String): String
124.  final def mkString(start: String, sep: String, end: String): String
125.  final def ne(arg0: AnyRef): Boolean
126.  final def notify(): Unit
127.  final def notifyAll(): Unit
128.  def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
129.  def padTo[B >: A](len: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
130.  def padTo[B >: A](len: Int, elem: B): collection.immutable.IndexedSeq[B]
131.  def partitionMap[A1, A2](f: (T) => Either[A1, A2])(implicit arg0: ClassTag[A1], arg1: ClassTag[A2]): (Array[A1], Array[A2])
132.  def partitionMap[A1, A2](f: (T) => Either[A1, A2]): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2])
133.  def patch[B >: A](from: Int, other: collection.IterableOnce[B], replaced: Int)(implicit arg0: ClassTag[B]): Array[B]
134.  def patch[B >: A](from: Int, other: collection.IterableOnce[B], replaced: Int): collection.immutable.IndexedSeq[B]
135.  def prepended[B >: A](x: B)(implicit arg0: ClassTag[B]): Array[B]
136.  def prepended[B >: A](elem: B): collection.immutable.IndexedSeq[B]
137.  def prependedAll[B >: A](prefix: Array[_ <: B])(implicit arg0: ClassTag[B]): Array[B]
138.  def prependedAll[B >: A](prefix: collection.IterableOnce[B])(implicit arg0: ClassTag[B]): Array[B]
139.  def prependedAll[B >: A](prefix: collection.IterableOnce[B]): collection.immutable.IndexedSeq[B]
140.  def product[B >: A](implicit num: math.Numeric[B]): B
141.  def reduce[B >: A](op: (B, B) => B): B
142.  def reduceLeft[B >: A](op: (B, T) => B): B
143.  def reduceLeftOption[B >: A](op: (B, T) => B): Option[B]
144.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
145.  def reduceRight[B >: A](op: (T, B) => B): B
146.  def reduceRightOption[B >: A](op: (T, B) => B): Option[B]
147.  def runWith[U](action: (T) => U): (Int) => Boolean
148.  def sameElements[B >: A](o: collection.IterableOnce[B]): Boolean
149.  def scan[B >: A](z: B)(op: (B, B) => B)(implicit arg0: ClassTag[B]): Array[B]
150.  def scan[B >: A](z: B)(op: (B, B) => B): collection.immutable.IndexedSeq[B]
151.  def scanLeft[B](z: B)(op: (B, T) => B)(implicit arg0: ClassTag[B]): Array[B]
152.  def scanLeft[B](z: B)(op: (B, T) => B): collection.immutable.IndexedSeq[B]
153.  def scanRight[B](z: B)(op: (T, B) => B)(implicit arg0: ClassTag[B]): Array[B]
154.  def scanRight[B](z: B)(op: (T, B) => B): collection.immutable.IndexedSeq[B]
155.  def search[B >: A](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
156.  def search[B >: A](elem: B)(implicit ord: math.Ordering[B]): SearchResult
157.  def segmentLength(p: (T) => Boolean, from: Int): Int
158.  final def segmentLength(p: (T) => Boolean): Int
159.  final def sizeCompare(that: collection.Iterable[_]): Int
160.  def sliding(size: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
161.  def sortBy[B](f: (T) => B)(implicit ord: math.Ordering[B]): Array[T]
162.  def sortBy[B](f: (T) => B)(implicit ord: Ordering[B]): collection.immutable.IndexedSeq[T]
163.  def sorted[B >: A](implicit ord: math.Ordering[B]): Array[T]
164.  def sorted[B >: A](implicit ord: Ordering[B]): collection.immutable.IndexedSeq[T]
165.  def startsWith[B >: A](that: collection.IterableOnce[B], offset: Int = 0): Boolean
166.  def startsWith[B >: A](that: Array[B], offset: Int): Boolean
167.  def startsWith[B >: A](that: Array[B]): Boolean
168.  def startsWith[B >: A](that: collection.IterableOnce[B], offset: Int = 0): Boolean
169.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
170.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S with EfficientSplit
171.  def subSequence(start: Int, end: Int): CharSequence
172.  def sum[B >: A](implicit num: math.Numeric[B]): B
173.  final def synchronized[T0](arg0: => T0): T0
174.  def tapEach[U](f: (T) => U): collection.immutable.IndexedSeq[T]
175.  def to[C1](factory: Factory[T, C1]): C1
176.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
177.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
178.  final def toBuffer[B >: A]: Buffer[B]
179.  final def toIterable: collection.immutable.IndexedSeq[T]
180.  def toList: collection.immutable.List[T]
181.  def toMap[K, V](implicit ev: <:<[T, (K, V)]): Map[K, V]
182.  def toSet[B >: A]: Set[B]
183.  def toString(): String
184.  def toVector: collection.immutable.Vector[T]
185.  def transpose[B](implicit asArray: (T) => Array[B]): Array[Array[B]]
186.  def transpose[B](implicit asIterable: (T) => collection.Iterable[B]): collection.immutable.IndexedSeq[collection.immutable.IndexedSeq[B]]
187.  def unapply(a: Int): Option[T]
188.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2), ct1: ClassTag[A1], ct2: ClassTag[A2]): (Array[A1], Array[A2])
189.  def unzip[A1, A2](implicit asPair: (T) => (A1, A2)): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2])
190.  def unzip3[A1, A2, A3](implicit asTriple: (T) => (A1, A2, A3), ct1: ClassTag[A1], ct2: ClassTag[A2], ct3: ClassTag[A3]): (Array[A1], Array[A2], Array[A3])
191.  def unzip3[A1, A2, A3](implicit asTriple: (T) => (A1, A2, A3)): (collection.immutable.IndexedSeq[A1], collection.immutable.IndexedSeq[A2], collection.immutable.IndexedSeq[A3])
192.  def update(i: Int, x: T): Unit
193.  def updated[B >: A](index: Int, elem: B)(implicit arg0: ClassTag[B]): Array[B]
194.  def updated[B >: A](index: Int, elem: B): collection.immutable.IndexedSeq[B]
195.  final def wait(): Unit
196.  final def wait(arg0: Long, arg1: Int): Unit
197.  final def wait(arg0: Long): Unit
198.  def zip[B](that: collection.IterableOnce[B]): Array[(T, B)]
199.  def zip[B](that: collection.IterableOnce[B]): collection.immutable.IndexedSeq[(T, B)]
200.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): Array[(A1, B)]
201.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): collection.immutable.IndexedSeq[(A1, B)]

Shadowed Implicit Value Members

1.  def apply(i: Int): T
2.  def combinations(n: Int): collection.Iterator[Array[T]]
3.  def combinations(n: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
4.  def contains(elem: T): Boolean
5.  def contains[A1 >: A](elem: A1): Boolean
6.  def count(p: (T) => Boolean): Int
7.  def count(p: (T) => Boolean): Int
8.  def distinct: Array[T]
9.  def distinct: collection.immutable.IndexedSeq[T]
10.  def drop(n: Int): Array[T]
11.  def drop(n: Int): collection.immutable.IndexedSeq[T]
12.  def dropRight(n: Int): Array[T]
13.  def dropRight(n: Int): collection.immutable.IndexedSeq[T]
14.  def dropWhile(p: (T) => Boolean): Array[T]
15.  def dropWhile(p: (T) => Boolean): collection.immutable.IndexedSeq[T]
16.  def equals(o: Any): Boolean
17.  def exists(f: (T) => Boolean): Boolean
18.  def exists(p: (T) => Boolean): Boolean
19.  def filter(p: (T) => Boolean): Array[T]
20.  def filter(pred: (T) => Boolean): collection.immutable.IndexedSeq[T]
21.  def filterNot(p: (T) => Boolean): Array[T]
22.  def filterNot(pred: (T) => Boolean): collection.immutable.IndexedSeq[T]
23.  def find(f: (T) => Boolean): Option[T]
24.  def find(p: (T) => Boolean): Option[T]
25.  def forall(f: (T) => Boolean): Boolean
26.  def forall(p: (T) => Boolean): Boolean
27.  def grouped(size: Int): collection.Iterator[Array[T]]
28.  def grouped(size: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
29.  def hashCode(): Int
30.  def head: T
31.  def head: T
32.  def headOption: Option[T]
33.  def headOption: Option[T]
34.  def indexOf(elem: T, from: Int = 0): Int
35.  def indexOf[B >: A](elem: B, from: Int): Int
36.  def indexWhere(f: (T) => Boolean, from: Int = 0): Int
37.  def indexWhere(p: (T) => Boolean, from: Int): Int
38.  def indices: collection.immutable.Range
39.  def indices: collection.immutable.Range
40.  def init: Array[T]
41.  def init: collection.immutable.IndexedSeq[T]
42.  def inits: collection.Iterator[Array[T]]
43.  def inits: collection.Iterator[collection.immutable.IndexedSeq[T]]
44.  def isEmpty: Boolean
45.  def isEmpty: Boolean
46.  def iterator: collection.Iterator[T]
47.  def iterator: collection.Iterator[T]
48.  def knownSize: Int
49.  def knownSize: Int
50.  def last: T
51.  def last: T
52.  def lastIndexOf(elem: T, end: Int = xs.length - 1): Int
53.  def lastIndexOf[B >: A](elem: B, end: Int = length - 1): Int
54.  def lastIndexWhere(p: (T) => Boolean, end: Int = xs.length - 1): Int
55.  def lastIndexWhere(p: (T) => Boolean, end: Int): Int
56.  def lastOption: Option[T]
57.  def lastOption: Option[T]
58.  def length(): Int
59.  def length: Int
60.  def lengthCompare(len: Int): Int
61.  final def lengthCompare(len: Int): Int
62.  def lengthIs: Int
63.  final def lengthIs: SizeCompareOps
64.  def nonEmpty: Boolean
65.  def nonEmpty: Boolean
66.  def partition(p: (T) => Boolean): (Array[T], Array[T])
67.  def partition(p: (T) => Boolean): (collection.immutable.IndexedSeq[T], collection.immutable.IndexedSeq[T])
68.  def permutations: collection.Iterator[Array[T]]
69.  def permutations: collection.Iterator[collection.immutable.IndexedSeq[T]]
70.  def reverse: Array[T]
71.  def reverse: collection.immutable.IndexedSeq[T]
72.  def reverseIterator: collection.Iterator[T]
73.  def reverseIterator: collection.Iterator[T]
74.  def size: Int
75.  final def size: Int
76.  def sizeCompare(otherSize: Int): Int
77.  final def sizeCompare(otherSize: Int): Int
78.  def sizeIs: Int
79.  final def sizeIs: SizeCompareOps
80.  def slice(from: Int, until: Int): Array[T]
81.  def slice(from: Int, until: Int): collection.immutable.IndexedSeq[T]
82.  def sliding(size: Int, step: Int = 1): collection.Iterator[Array[T]]
83.  def sliding(size: Int, step: Int): collection.Iterator[collection.immutable.IndexedSeq[T]]
84.  def sortWith(lt: (T, T) => Boolean): Array[T]
85.  def sortWith(lt: (T, T) => Boolean): collection.immutable.IndexedSeq[T]
86.  def span(p: (T) => Boolean): (Array[T], Array[T])
87.  def span(p: (T) => Boolean): (collection.immutable.IndexedSeq[T], collection.immutable.IndexedSeq[T])
88.  def splitAt(n: Int): (Array[T], Array[T])
89.  def splitAt(n: Int): (collection.immutable.IndexedSeq[T], collection.immutable.IndexedSeq[T])
90.  def tail: Array[T]
91.  def tail: collection.immutable.IndexedSeq[T]
92.  def tails: collection.Iterator[Array[T]]
93.  def tails: collection.Iterator[collection.immutable.IndexedSeq[T]]
94.  def take(n: Int): Array[T]
95.  def take(n: Int): collection.immutable.IndexedSeq[T]
96.  def takeRight(n: Int): Array[T]
97.  def takeRight(n: Int): collection.immutable.IndexedSeq[T]
98.  def takeWhile(p: (T) => Boolean): Array[T]
99.  def takeWhile(p: (T) => Boolean): collection.immutable.IndexedSeq[T]
100.  def toIndexedSeq: collection.immutable.IndexedSeq[T]
101.  final def toIndexedSeq: collection.immutable.IndexedSeq[T]
102.  final def toSeq: collection.immutable.Seq[T]
103.  final def toSeq: collection.immutable.IndexedSeq[T]
104.  def toString(): String
105.  def toString(): String
106.  def view: IndexedSeqView[T]
107.  def view: IndexedSeqView[T]
108.  def withFilter(p: (T) => Boolean): WithFilter[T]
109.  def withFilter(p: (T) => Boolean): WithFilter[T, [_]collection.immutable.IndexedSeq[_]]
110.  def zipWithIndex: Array[(T, Int)]
111.  def zipWithIndex: collection.immutable.IndexedSeq[(T, Int)]

Deprecated Value Members

1.  final def /:[B](z: B)(op: (B, T) => B): B
2.  final def :\[B](z: B)(op: (T, B) => B): B
3.  def aggregate[B](z: => B)(seqop: (B, T) => B, combop: (B, B) => B): B
4.  def companion: IterableFactory[[_]collection.immutable.IndexedSeq[_]]
5.  final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
6.  def hasDefiniteSize: Boolean
7.  final def prefixLength(p: (T) => Boolean): Int
8.  final def repr: collection.immutable.IndexedSeq[T]
9.  def reverseMap[B](f: (T) => B): collection.immutable.IndexedSeq[B]
10.  def seq: collection.immutable.IndexedSeq[T]
11.  final def toIterator: collection.Iterator[T]
12.  final def toStream: collection.immutable.Stream[T]
13.  final def toTraversable: collection.Traversable[T]
14.  final def union[B >: A](that: collection.Seq[B]): collection.immutable.IndexedSeq[B]
15.  def view(from: Int, until: Int): IndexedSeqView[T]
16.  def →[B](y: B): (Array[T], B)

Ungrouped