final
class
ConstArray[+T] extends Product
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(other: String): String
-
def
++(o: Option[T]): ConstArray[T]
-
-
-
def
->[B](y: B): (ConstArray[T], B)
-
-
final
def
==(arg0: Any): Boolean
-
def
apply(i: Int): T
-
final
def
asInstanceOf[T0]: T0
-
def
canEqual(that: Any): Boolean
-
def
clone(): AnyRef
-
def
collect[R](f: PartialFunction[T, R]): ConstArray[R]
-
def
drop(n: Int): ConstArray[T]
-
def
endoMap(f: (T) ⇒ T): ConstArray[T]
-
def
ensuring(cond: (ConstArray[T]) ⇒ Boolean, msg: ⇒ Any): ConstArray[T]
-
-
def
ensuring(cond: Boolean, msg: ⇒ Any): ConstArray[T]
-
def
ensuring(cond: Boolean): ConstArray[T]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(o: Any): Boolean
-
def
exists(f: (T) ⇒ Boolean): Boolean
-
def
filter(p: (T) ⇒ Boolean): ConstArray[T]
-
def
finalize(): Unit
-
def
find(f: (T) ⇒ Boolean): Option[T]
-
-
def
flatten[R](implicit ev: <:<[T, ConstArray[R]]): ConstArray[R]
-
def
foldLeft[B](z: B)(op: (B, T) ⇒ B): B
-
def
foldRight[B](z: B)(op: (T, B) ⇒ B): B
-
def
forall(f: (T) ⇒ Boolean): Boolean
-
def
foreach[R](f: (T) ⇒ R): Unit
-
def
formatted(fmtstr: String): String
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
def
head: T
-
def
headOption: Option[T]
-
def
indexWhere(f: (T) ⇒ Boolean): Int
-
-
def
isEmpty: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
iterator: Iterator[T]
-
def
last: T
-
def
lastOption: Option[T]
-
val
length: Int
-
def
lengthCompare(n: Int): Int
-
def
map[R](f: (T) ⇒ R): ConstArray[R]
-
def
mkString(start: String, sep: String, end: String): String
-
def
mkString(sep: String): String
-
final
def
ne(arg0: AnyRef): Boolean
-
def
nonEmpty: Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
productArity: Int
-
def
productElement(i: Int): Any
-
def
productIterator: Iterator[Any]
-
def
productPrefix: String
-
def
slice(from: Int, until: Int): ConstArray[T]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
def
take(n: Int): ConstArray[T]
-
def
toArray[R >: T](implicit arg0: ClassTag[R]): Array[R]
-
def
toMap[R, U](implicit ev: <:<[T, (R, U)]): HashMap[R, U]
-
def
toSeq: IndexedSeq[T]
-
def
toSet: HashSet[T]
-
def
toString(): String
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
withFilter(p: (T) ⇒ Boolean): ConstArrayOp[T]
-
-
def
zipWithIndex: ConstArrayOp[(T, Int)]
-
def
→[B](y: B): (ConstArray[T], B)
Inherited from Product
Inherited from Equals
Inherited from AnyRef
Inherited from Any
An efficient immutable array implementation which is used in the AST. Semantics are generally the same as for Scala collections but for performance reasons it does not implement any standard collection traits.