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: Any): Boolean

    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Definition Classes
    AnyRef → Any

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

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

    Definition Classes
    AnyRef → Any

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

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

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  8. def clone(): AnyRef

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

  9. 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  27. 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

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

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

  29. def contains(elem: X): Boolean

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef

  38. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

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

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

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

  42. def finalize(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef → Any

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

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

    Annotations
    @throws( ... )

  100. def hashCode(): Int

    Definition Classes
    AnyRef → Any

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

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

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

  104. def intersperse(a: X): ofRef[X]

  105. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

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

  107. def length: Int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  123. def mkString: String

  124. def mkString(sep: String): String

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

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

    Definition Classes
    AnyRef

  127. final def notify(): Unit

    Definition Classes
    AnyRef

  128. final def notifyAll(): Unit

    Definition Classes
    AnyRef

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

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

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

  132. def reverse: ofRef[X]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  166. val self: Array[X]

  167. def size: Int

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

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

    Annotations
    @throws( ... )

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

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

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

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

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

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

    Definition Classes
    AnyRef

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

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

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

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

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

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

  182. def toString(): String

    Definition Classes
    ofRef → AnyRef → Any

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

    Annotations
    @throws( ... )

  184. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

Inherited from AnyRef

Inherited from Any

Ungrouped