Scala Standard Library 2.13.15 - 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 copyArrayToImmutableIndexedSeq

3. by any2stringadd

4. by StringFormat

5. by Ensuring

6. by ArrowAssoc

7. Hide All

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

Ungrouped