nobox

ofRef

final class ofRef[X <: AnyRef] extends AnyRef

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. ofRef
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ofRef(self: Array[X])(implicit arg0: ClassTag[X])

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. def ++(that: ofRef[X]): ofRef[X]

  5. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  6. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  7. def ===(that: ofRef[X]): Boolean

  8. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

  9. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  10. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  11. def collect[A](f: PartialFunction[X, A])(implicit A: ClassTag[A]): Array[A]

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  12. def collectBoolean(f: PartialFunction[X, Boolean]): ofBoolean

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  13. def collectByte(f: PartialFunction[X, Byte]): ofByte

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  14. def collectChar(f: PartialFunction[X, Char]): ofChar

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  15. def collectDouble(f: PartialFunction[X, Double]): ofDouble

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  16. def collectFirst[A](f: PartialFunction[X, A])(implicit A: ClassTag[A]): Option[A]

  17. def collectFirstBoolean(f: PartialFunction[X, Boolean]): Option[Boolean]

  18. def collectFirstByte(f: PartialFunction[X, Byte]): Option[Byte]

  19. def collectFirstChar(f: PartialFunction[X, Char]): Option[Char]

  20. def collectFirstDouble(f: PartialFunction[X, Double]): Option[Double]

  21. def collectFirstFloat(f: PartialFunction[X, Float]): Option[Float]

  22. def collectFirstInt(f: PartialFunction[X, Int]): Option[Int]

  23. def collectFirstLong(f: PartialFunction[X, Long]): Option[Long]

  24. def collectFirstRef[Y <: AnyRef](f: PartialFunction[X, Y])(implicit arg0: ClassTag[Y]): Option[Y]

  25. def collectFirstShort(f: PartialFunction[X, Short]): Option[Short]

  26. def collectFloat(f: PartialFunction[X, Float]): ofFloat

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  27. def collectInt(f: PartialFunction[X, Int]): ofInt

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  28. def collectLong(f: PartialFunction[X, Long]): ofLong

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  29. def collectRef[Y <: AnyRef](f: PartialFunction[X, Y])(implicit arg0: ClassTag[Y]): ofRef[Y]

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  30. def collectShort(f: PartialFunction[X, Short]): ofShort

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  31. def contains(elem: X): Boolean

  32. def count(f: (X) ⇒ Boolean): Int

  33. def deleteFirst(elem: X): ofRef[X]

  34. def drop(n: Int): ofRef[X]

  35. def dropRight(n: Int): ofRef[X]

  36. def dropWhile(f: (X) ⇒ Boolean): ofRef[X]

  37. def dropWhileR(f: (X) ⇒ Boolean): ofRef[X]

  38. def endsWith(that: Array[X]): Boolean

  39. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  40. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  41. def exists(f: (X) ⇒ Boolean): Boolean

  42. def filter(f: (X) ⇒ Boolean): ofRef[X]

  43. def filterNot(f: (X) ⇒ Boolean): ofRef[X]

  44. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  45. def find(f: (X) ⇒ Boolean): Option[X]

  46. def flatMap[A](f: (X) ⇒ Array[A])(implicit A: ClassTag[A]): Array[A]

  47. def flatMapBoolean(f: (X) ⇒ Array[Boolean]): ofBoolean

  48. def flatMapByte(f: (X) ⇒ Array[Byte]): ofByte

  49. def flatMapChar(f: (X) ⇒ Array[Char]): ofChar

  50. def flatMapDouble(f: (X) ⇒ Array[Double]): ofDouble

  51. def flatMapFloat(f: (X) ⇒ Array[Float]): ofFloat

  52. def flatMapInt(f: (X) ⇒ Array[Int]): ofInt

  53. def flatMapLong(f: (X) ⇒ Array[Long]): ofLong

  54. def flatMapRef[Y <: AnyRef](f: (X) ⇒ Array[Y])(implicit arg0: ClassTag[Y]): ofRef[Y]

  55. def flatMapShort(f: (X) ⇒ Array[Short]): ofShort

  56. def flatten[E](implicit E: <:<[X, Array[E]]): Array[E]

  57. def foldLeft[A](z: A)(f: (A, X) ⇒ A)(implicit A: ClassTag[A]): A

  58. def foldLeftBoolean(z: Boolean)(f: (Boolean, X) ⇒ Boolean): Boolean

  59. def foldLeftByte(z: Byte)(f: (Byte, X) ⇒ Byte): Byte

  60. def foldLeftChar(z: Char)(f: (Char, X) ⇒ Char): Char

  61. def foldLeftDouble(z: Double)(f: (Double, X) ⇒ Double): Double

  62. def foldLeftFloat(z: Float)(f: (Float, X) ⇒ Float): Float

  63. def foldLeftInt(z: Int)(f: (Int, X) ⇒ Int): Int

  64. def foldLeftLong(z: Long)(f: (Long, X) ⇒ Long): Long

  65. def foldLeftRef[Y](z: Y)(f: (Y, X) ⇒ Y): Y

  66. def foldLeftShort(z: Short)(f: (Short, X) ⇒ Short): Short

  67. def foldMapLeft1[A](z: (X) ⇒ A)(f: (A, X) ⇒ A)(implicit A: ClassTag[A]): Option[A]

  68. def foldMapLeft1Boolean(z: (X) ⇒ Boolean)(f: (Boolean, X) ⇒ Boolean): Option[Boolean]

  69. def foldMapLeft1Byte(z: (X) ⇒ Byte)(f: (Byte, X) ⇒ Byte): Option[Byte]

  70. def foldMapLeft1Char(z: (X) ⇒ Char)(f: (Char, X) ⇒ Char): Option[Char]

  71. def foldMapLeft1Double(z: (X) ⇒ Double)(f: (Double, X) ⇒ Double): Option[Double]

  72. def foldMapLeft1Float(z: (X) ⇒ Float)(f: (Float, X) ⇒ Float): Option[Float]

  73. def foldMapLeft1Int(z: (X) ⇒ Int)(f: (Int, X) ⇒ Int): Option[Int]

  74. def foldMapLeft1Long(z: (X) ⇒ Long)(f: (Long, X) ⇒ Long): Option[Long]

  75. def foldMapLeft1Ref[Y](z: (X) ⇒ Y)(f: (Y, X) ⇒ Y): Option[Y]

  76. def foldMapLeft1Short(z: (X) ⇒ Short)(f: (Short, X) ⇒ Short): Option[Short]

  77. def foldMapRight1[A](z: (X) ⇒ A)(f: (X, A) ⇒ A)(implicit A: ClassTag[A]): Option[A]

  78. def foldMapRight1Boolean(z: (X) ⇒ Boolean)(f: (X, Boolean) ⇒ Boolean): Option[Boolean]

  79. def foldMapRight1Byte(z: (X) ⇒ Byte)(f: (X, Byte) ⇒ Byte): Option[Byte]

  80. def foldMapRight1Char(z: (X) ⇒ Char)(f: (X, Char) ⇒ Char): Option[Char]

  81. def foldMapRight1Double(z: (X) ⇒ Double)(f: (X, Double) ⇒ Double): Option[Double]

  82. def foldMapRight1Float(z: (X) ⇒ Float)(f: (X, Float) ⇒ Float): Option[Float]

  83. def foldMapRight1Int(z: (X) ⇒ Int)(f: (X, Int) ⇒ Int): Option[Int]

  84. def foldMapRight1Long(z: (X) ⇒ Long)(f: (X, Long) ⇒ Long): Option[Long]

  85. def foldMapRight1Ref[Y](z: (X) ⇒ Y)(f: (X, Y) ⇒ Y): Option[Y]

  86. def foldMapRight1Short(z: (X) ⇒ Short)(f: (X, Short) ⇒ Short): Option[Short]

  87. def foldRight[A](z: A)(f: (X, A) ⇒ A)(implicit A: ClassTag[A]): A

  88. def foldRightBoolean(z: Boolean)(f: (X, Boolean) ⇒ Boolean): Boolean

  89. def foldRightByte(z: Byte)(f: (X, Byte) ⇒ Byte): Byte

  90. def foldRightChar(z: Char)(f: (X, Char) ⇒ Char): Char

  91. def foldRightDouble(z: Double)(f: (X, Double) ⇒ Double): Double

  92. def foldRightFloat(z: Float)(f: (X, Float) ⇒ Float): Float

  93. def foldRightInt(z: Int)(f: (X, Int) ⇒ Int): Int

  94. def foldRightLong(z: Long)(f: (X, Long) ⇒ Long): Long

  95. def foldRightRef[Y](z: Y)(f: (X, Y) ⇒ Y): Y

  96. def foldRightShort(z: Short)(f: (X, Short) ⇒ Short): Short

  97. def forall(f: (X) ⇒ Boolean): Boolean

  98. def foreach[U](f: (X) ⇒ U): Unit

  99. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  100. def groupBy[A](f: (X) ⇒ A): Map[A, ofRef[X]]

  101. def grouped(n: Int): Iterator[ofRef[X]]

    Annotations
    @throws( ... )

  102. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  103. def indexOf(elem: X): Option[Int]

  104. def initOption: Option[ofRef[X]]

  105. def inits: Iterator[ofRef[X]]

  106. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  107. def lastIndexOf(elem: X): Option[Int]

  108. def length: Int

  109. def map[A](f: (X) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  110. def mapBoolean(f: (X) ⇒ Boolean): ofBoolean

  111. def mapByte(f: (X) ⇒ Byte): ofByte

  112. def mapChar(f: (X) ⇒ Char): ofChar

  113. def mapDouble(f: (X) ⇒ Double): ofDouble

  114. def mapFloat(f: (X) ⇒ Float): ofFloat

  115. def mapInt(f: (X) ⇒ Int): ofInt

  116. def mapLong(f: (X) ⇒ Long): ofLong

  117. def mapRef[Y <: AnyRef](f: (X) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  118. def mapShort(f: (X) ⇒ Short): ofShort

  119. def max[B >: X](implicit O: Ordering[B]): Option[X]

  120. def maxBy[A](f: (X) ⇒ A)(implicit A: Ordering[A]): Option[X]

  121. def min[B >: X](implicit O: Ordering[B]): Option[X]

  122. def minBy[A](f: (X) ⇒ A)(implicit A: Ordering[A]): Option[X]

  123. def minmax[B >: X](implicit O: Ordering[B]): Option[(X, X)]

  124. def mkString: String

  125. def mkString(sep: String): String

  126. def mkString(start: String, sep: String, end: String): String

  127. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  128. final def notify(): Unit

    Definition Classes
    AnyRef

  129. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  130. def partition(f: (X) ⇒ Boolean): (ofRef[X], ofRef[X])

  131. def reduceLeftOption(f: (X, X) ⇒ X): Option[X]

  132. def reduceRightOption(f: (X, X) ⇒ X): Option[X]

  133. def reverse: ofRef[X]

  134. def reverseMap[A](f: (X) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  135. def reverseMapBoolean(f: (X) ⇒ Boolean): ofBoolean

  136. def reverseMapByte(f: (X) ⇒ Byte): ofByte

  137. def reverseMapChar(f: (X) ⇒ Char): ofChar

  138. def reverseMapDouble(f: (X) ⇒ Double): ofDouble

  139. def reverseMapFloat(f: (X) ⇒ Float): ofFloat

  140. def reverseMapInt(f: (X) ⇒ Int): ofInt

  141. def reverseMapLong(f: (X) ⇒ Long): ofLong

  142. def reverseMapRef[Y <: AnyRef](f: (X) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  143. def reverseMapShort(f: (X) ⇒ Short): ofShort

  144. def reverse_:::(prefix: ofRef[X]): ofRef[X]

  145. def scanLeft[A](z: A)(f: (A, X) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  146. def scanLeft1(f: (X, X) ⇒ X): ofRef[X]

  147. def scanLeftBoolean(z: Boolean)(f: (Boolean, X) ⇒ Boolean): ofBoolean

  148. def scanLeftByte(z: Byte)(f: (Byte, X) ⇒ Byte): ofByte

  149. def scanLeftChar(z: Char)(f: (Char, X) ⇒ Char): ofChar

  150. def scanLeftDouble(z: Double)(f: (Double, X) ⇒ Double): ofDouble

  151. def scanLeftFloat(z: Float)(f: (Float, X) ⇒ Float): ofFloat

  152. def scanLeftInt(z: Int)(f: (Int, X) ⇒ Int): ofInt

  153. def scanLeftLong(z: Long)(f: (Long, X) ⇒ Long): ofLong

  154. def scanLeftRef[Y <: AnyRef](z: Y)(f: (Y, X) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  155. def scanLeftShort(z: Short)(f: (Short, X) ⇒ Short): ofShort

  156. def scanRight[A](z: A)(f: (X, A) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  157. def scanRight1(f: (X, X) ⇒ X): ofRef[X]

  158. def scanRightBoolean(z: Boolean)(f: (X, Boolean) ⇒ Boolean): ofBoolean

  159. def scanRightByte(z: Byte)(f: (X, Byte) ⇒ Byte): ofByte

  160. def scanRightChar(z: Char)(f: (X, Char) ⇒ Char): ofChar

  161. def scanRightDouble(z: Double)(f: (X, Double) ⇒ Double): ofDouble

  162. def scanRightFloat(z: Float)(f: (X, Float) ⇒ Float): ofFloat

  163. def scanRightInt(z: Int)(f: (X, Int) ⇒ Int): ofInt

  164. def scanRightLong(z: Long)(f: (X, Long) ⇒ Long): ofLong

  165. def scanRightRef[Y <: AnyRef](z: Y)(f: (X, Y) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  166. def scanRightShort(z: Short)(f: (X, Short) ⇒ Short): ofShort

  167. val self: Array[X]

  168. def size: Int

  169. def slice(from: Int, until: Int): ofRef[X]

  170. def sliding(_size: Int, step: Int = 1): Iterator[ofRef[X]]

    Annotations
    @throws( ... )

  171. def sorted(implicit ord: Ordering[X]): ofRef[X]

  172. def span(f: (X) ⇒ Boolean): (ofRef[X], ofRef[X])

  173. def splitAt(n: Int): (ofRef[X], ofRef[X])

  174. def startsWith(that: Array[X], offset: Int = 0): Boolean

  175. def sum(implicit X: Numeric[X]): X

  176. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef

  177. def tailOption: Option[ofRef[X]]

  178. def tails: Iterator[ofRef[X]]

  179. def take(n: Int): ofRef[X]

  180. def takeRight(n: Int): ofRef[X]

  181. def takeWhile(f: (X) ⇒ Boolean): ofRef[X]

  182. def takeWhileR(f: (X) ⇒ Boolean): ofRef[X]

  183. def toString(): String

    Definition Classes
    ofRef → AnyRef → Any

  184. def updated(index: Int, elem: X): ofRef[X]

    Annotations
    @throws( ... )

  185. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  186. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  187. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  188. def withFilter(f: (X) ⇒ Boolean): WithFilterRef[X]

Inherited from AnyRef

Inherited from Any

Ungrouped