nobox

ofRef

Related Docs: object ofRef | package nobox

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

    Annotations
    @inline()

  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 interleave(that: ofRef[X]): ofRef[X]

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

  106. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

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

  108. def length: Int

    Annotations
    @inline()

  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

    Annotations
    @inline()

  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 toArray: Array[X]

  184. def toList: List[X]

  185. def toString(): String

    Definition Classes
    ofRef → AnyRef → Any

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

    Annotations
    @throws( ... )

  187. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

Inherited from AnyRef

Inherited from Any

Ungrouped