Packages

final class ConstArray[+T] extends Product

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.

Self Type
ConstArray[T]
Source
ConstArray.scala
Linear Supertypes
Product, Equals, AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ConstArray
  2. Product
  3. Equals
  4. AnyRef
  5. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. def ++(o: Option[T]): ConstArray[T]
  2. def ++[U >: T](u: ConstArray[U]): ConstArray[U]
  3. def +:(v: T): ConstArray[T]
  4. def :+(v: T): ConstArray[T]
  5. def apply(i: Int): T
  6. def canEqual(that: Any): Boolean
    Definition Classes
    ConstArray → Equals
  7. def collect[R](f: PartialFunction[T, R]): ConstArray[R]
  8. def drop(n: Int): ConstArray[T]
  9. def endoMap(f: (T) => T): ConstArray[T]

    Perform a mapping operation that does not change the type.

    Perform a mapping operation that does not change the type. If all elements remain unchanged (as determined by object identity), return this ConstArray instead of building a new one.

  10. def equals(o: Any): Boolean
    Definition Classes
    ConstArray → Equals → AnyRef → Any
  11. def exists(f: (T) => Boolean): Boolean
  12. def filter(p: (T) => Boolean): ConstArray[T]
  13. def find(f: (T) => Boolean): Option[T]
  14. def flatMap[R](f: (T) => ConstArray[R]): ConstArray[R]
  15. def flatten[R](implicit ev: <:<[T, ConstArray[R]]): ConstArray[R]
  16. def foldLeft[B](z: B)(op: (B, T) => B): B
  17. def foldRight[B](z: B)(op: (T, B) => B): B
  18. def forall(f: (T) => Boolean): Boolean
  19. def foreach[R](f: (T) => R): Unit
  20. def hashCode(): Int
    Definition Classes
    ConstArray → AnyRef → Any
  21. def head: T
  22. def headOption: Option[T]
  23. def indexWhere(f: (T) => Boolean): Int
  24. def init: ConstArray[T]
  25. def isEmpty: Boolean
  26. def iterator: Iterator[T]
  27. def last: T
  28. def lastOption: Option[T]
  29. val length: Int
  30. def lengthCompare(n: Int): Int
  31. def map[R](f: (T) => R): ConstArray[R]
  32. def mkString(start: String, sep: String, end: String): String
  33. def mkString(sep: String): String
  34. def nonEmpty: Boolean
  35. def productArity: Int
    Definition Classes
    ConstArray → Product
  36. def productElement(i: Int): Any
    Definition Classes
    ConstArray → Product
  37. def productElementName(n: Int): String
    Definition Classes
    Product
  38. def productElementNames: Iterator[String]
    Definition Classes
    Product
  39. def productIterator: Iterator[Any]
    Definition Classes
    Product
  40. def productPrefix: String
    Definition Classes
    ConstArray → Product
  41. def slice(from: Int, until: Int): ConstArray[T]
  42. def tail: ConstArray[T]
  43. def take(n: Int): ConstArray[T]
  44. def toArray[R >: T](implicit arg0: ClassTag[R]): Array[R]
  45. def toMap[R, U](implicit ev: <:<[T, (R, U)]): HashMap[R, U]
  46. def toSeq: IndexedSeq[T]
  47. def toSet: HashSet[T]
  48. def toString(): String
    Definition Classes
    ConstArray → AnyRef → Any
  49. def withFilter(p: (T) => Boolean): ConstArrayOp[T]
  50. def zip[U](u: ConstArray[U]): ConstArrayOp[(T, U)]
  51. def zipWithIndex: ConstArrayOp[(T, Int)]