nobox

ofBoolean

final class ofBoolean extends AnyVal

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

Instance Constructors

  1. new ofBoolean(self: Array[Boolean])

Value Members

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

    Definition Classes
    Any

  2. final def ##(): Int

    Definition Classes
    Any

  3. def ++(that: ofBoolean): ofBoolean

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

    Definition Classes
    Any

  5. def ===(that: ofBoolean): Boolean

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

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  8. def collect[A](f: PartialFunction[Boolean, A])(implicit A: ClassTag[A]): Array[A]

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

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

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

  10. def collectByte(f: PartialFunction[Boolean, Byte]): ofByte

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

  11. def collectChar(f: PartialFunction[Boolean, Char]): ofChar

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

  12. def collectDouble(f: PartialFunction[Boolean, Double]): ofDouble

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

  13. def collectFirst[A](f: PartialFunction[Boolean, A])(implicit A: ClassTag[A]): Option[A]

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

  15. def collectFirstByte(f: PartialFunction[Boolean, Byte]): Option[Byte]

  16. def collectFirstChar(f: PartialFunction[Boolean, Char]): Option[Char]

  17. def collectFirstDouble(f: PartialFunction[Boolean, Double]): Option[Double]

  18. def collectFirstFloat(f: PartialFunction[Boolean, Float]): Option[Float]

  19. def collectFirstInt(f: PartialFunction[Boolean, Int]): Option[Int]

  20. def collectFirstLong(f: PartialFunction[Boolean, Long]): Option[Long]

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

  22. def collectFirstShort(f: PartialFunction[Boolean, Short]): Option[Short]

  23. def collectFloat(f: PartialFunction[Boolean, Float]): ofFloat

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

  24. def collectInt(f: PartialFunction[Boolean, Int]): ofInt

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

  25. def collectLong(f: PartialFunction[Boolean, Long]): ofLong

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

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

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

  27. def collectShort(f: PartialFunction[Boolean, Short]): ofShort

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

  28. def contains(elem: Boolean): Boolean

  29. def count(f: (Boolean) ⇒ Boolean): Int

  30. def deleteFirst(elem: Boolean): ofBoolean

  31. def drop(n: Int): ofBoolean

  32. def dropRight(n: Int): ofBoolean

  33. def dropWhile(f: (Boolean) ⇒ Boolean): ofBoolean

  34. def dropWhileR(f: (Boolean) ⇒ Boolean): ofBoolean

  35. def endsWith(that: Array[Boolean]): Boolean

  36. def exists(f: (Boolean) ⇒ Boolean): Boolean

  37. def filter(f: (Boolean) ⇒ Boolean): ofBoolean

  38. def filterNot(f: (Boolean) ⇒ Boolean): ofBoolean

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

  40. def flatMap[A](f: (Boolean) ⇒ Array[A])(implicit A: ClassTag[A]): Array[A]

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

  42. def flatMapByte(f: (Boolean) ⇒ Array[Byte]): ofByte

  43. def flatMapChar(f: (Boolean) ⇒ Array[Char]): ofChar

  44. def flatMapDouble(f: (Boolean) ⇒ Array[Double]): ofDouble

  45. def flatMapFloat(f: (Boolean) ⇒ Array[Float]): ofFloat

  46. def flatMapInt(f: (Boolean) ⇒ Array[Int]): ofInt

  47. def flatMapLong(f: (Boolean) ⇒ Array[Long]): ofLong

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

  49. def flatMapShort(f: (Boolean) ⇒ Array[Short]): ofShort

  50. def foldLeft[A](z: A)(f: (A, Boolean) ⇒ A)(implicit A: ClassTag[A]): A

  51. def foldLeftBoolean(z: Boolean)(f: (Boolean, Boolean) ⇒ Boolean): Boolean

  52. def foldLeftByte(z: Byte)(f: (Byte, Boolean) ⇒ Byte): Byte

  53. def foldLeftChar(z: Char)(f: (Char, Boolean) ⇒ Char): Char

  54. def foldLeftDouble(z: Double)(f: (Double, Boolean) ⇒ Double): Double

  55. def foldLeftFloat(z: Float)(f: (Float, Boolean) ⇒ Float): Float

  56. def foldLeftInt(z: Int)(f: (Int, Boolean) ⇒ Int): Int

  57. def foldLeftLong(z: Long)(f: (Long, Boolean) ⇒ Long): Long

  58. def foldLeftRef[Y](z: Y)(f: (Y, Boolean) ⇒ Y): Y

  59. def foldLeftShort(z: Short)(f: (Short, Boolean) ⇒ Short): Short

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

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

  62. def foldMapLeft1Byte(z: (Boolean) ⇒ Byte)(f: (Byte, Boolean) ⇒ Byte): Option[Byte]

  63. def foldMapLeft1Char(z: (Boolean) ⇒ Char)(f: (Char, Boolean) ⇒ Char): Option[Char]

  64. def foldMapLeft1Double(z: (Boolean) ⇒ Double)(f: (Double, Boolean) ⇒ Double): Option[Double]

  65. def foldMapLeft1Float(z: (Boolean) ⇒ Float)(f: (Float, Boolean) ⇒ Float): Option[Float]

  66. def foldMapLeft1Int(z: (Boolean) ⇒ Int)(f: (Int, Boolean) ⇒ Int): Option[Int]

  67. def foldMapLeft1Long(z: (Boolean) ⇒ Long)(f: (Long, Boolean) ⇒ Long): Option[Long]

  68. def foldMapLeft1Ref[Y](z: (Boolean) ⇒ Y)(f: (Y, Boolean) ⇒ Y): Option[Y]

  69. def foldMapLeft1Short(z: (Boolean) ⇒ Short)(f: (Short, Boolean) ⇒ Short): Option[Short]

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

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

  72. def foldMapRight1Byte(z: (Boolean) ⇒ Byte)(f: (Boolean, Byte) ⇒ Byte): Option[Byte]

  73. def foldMapRight1Char(z: (Boolean) ⇒ Char)(f: (Boolean, Char) ⇒ Char): Option[Char]

  74. def foldMapRight1Double(z: (Boolean) ⇒ Double)(f: (Boolean, Double) ⇒ Double): Option[Double]

  75. def foldMapRight1Float(z: (Boolean) ⇒ Float)(f: (Boolean, Float) ⇒ Float): Option[Float]

  76. def foldMapRight1Int(z: (Boolean) ⇒ Int)(f: (Boolean, Int) ⇒ Int): Option[Int]

  77. def foldMapRight1Long(z: (Boolean) ⇒ Long)(f: (Boolean, Long) ⇒ Long): Option[Long]

  78. def foldMapRight1Ref[Y](z: (Boolean) ⇒ Y)(f: (Boolean, Y) ⇒ Y): Option[Y]

  79. def foldMapRight1Short(z: (Boolean) ⇒ Short)(f: (Boolean, Short) ⇒ Short): Option[Short]

  80. def foldRight[A](z: A)(f: (Boolean, A) ⇒ A)(implicit A: ClassTag[A]): A

  81. def foldRightBoolean(z: Boolean)(f: (Boolean, Boolean) ⇒ Boolean): Boolean

  82. def foldRightByte(z: Byte)(f: (Boolean, Byte) ⇒ Byte): Byte

  83. def foldRightChar(z: Char)(f: (Boolean, Char) ⇒ Char): Char

  84. def foldRightDouble(z: Double)(f: (Boolean, Double) ⇒ Double): Double

  85. def foldRightFloat(z: Float)(f: (Boolean, Float) ⇒ Float): Float

  86. def foldRightInt(z: Int)(f: (Boolean, Int) ⇒ Int): Int

  87. def foldRightLong(z: Long)(f: (Boolean, Long) ⇒ Long): Long

  88. def foldRightRef[Y](z: Y)(f: (Boolean, Y) ⇒ Y): Y

  89. def foldRightShort(z: Short)(f: (Boolean, Short) ⇒ Short): Short

  90. def forall(f: (Boolean) ⇒ Boolean): Boolean

  91. def foreach[U](f: (Boolean) ⇒ U): Unit

  92. def getClass(): Class[_ <: AnyVal]

    Definition Classes
    AnyVal → Any

  93. def groupBy[A](f: (Boolean) ⇒ A): Map[A, ofBoolean]

  94. def grouped(n: Int): Iterator[ofBoolean]

    Annotations
    @throws( ... )

  95. def indexOf(elem: Boolean): Option[Int]

  96. def initOption: Option[ofBoolean]

  97. def inits: Iterator[ofBoolean]

  98. def intersperse(a: Boolean): ofBoolean

  99. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  100. def lastIndexOf(elem: Boolean): Option[Int]

  101. def length: Int

  102. def map[A](f: (Boolean) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  103. def mapBoolean(f: (Boolean) ⇒ Boolean): ofBoolean

  104. def mapByte(f: (Boolean) ⇒ Byte): ofByte

  105. def mapChar(f: (Boolean) ⇒ Char): ofChar

  106. def mapDouble(f: (Boolean) ⇒ Double): ofDouble

  107. def mapFloat(f: (Boolean) ⇒ Float): ofFloat

  108. def mapInt(f: (Boolean) ⇒ Int): ofInt

  109. def mapLong(f: (Boolean) ⇒ Long): ofLong

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

  111. def mapShort(f: (Boolean) ⇒ Short): ofShort

  112. def max: Option[Boolean]

  113. def maxBy[A](f: (Boolean) ⇒ A)(implicit A: Ordering[A]): Option[Boolean]

  114. def min: Option[Boolean]

  115. def minBy[A](f: (Boolean) ⇒ A)(implicit A: Ordering[A]): Option[Boolean]

  116. def minmax: Option[(Boolean, Boolean)]

  117. def mkString: String

  118. def mkString(sep: String): String

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

  120. def partition(f: (Boolean) ⇒ Boolean): (ofBoolean, ofBoolean)

  121. def reduceLeftOption(f: (Boolean, Boolean) ⇒ Boolean): Option[Boolean]

  122. def reduceRightOption(f: (Boolean, Boolean) ⇒ Boolean): Option[Boolean]

  123. def reverse: ofBoolean

  124. def reverseMap[A](f: (Boolean) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  125. def reverseMapBoolean(f: (Boolean) ⇒ Boolean): ofBoolean

  126. def reverseMapByte(f: (Boolean) ⇒ Byte): ofByte

  127. def reverseMapChar(f: (Boolean) ⇒ Char): ofChar

  128. def reverseMapDouble(f: (Boolean) ⇒ Double): ofDouble

  129. def reverseMapFloat(f: (Boolean) ⇒ Float): ofFloat

  130. def reverseMapInt(f: (Boolean) ⇒ Int): ofInt

  131. def reverseMapLong(f: (Boolean) ⇒ Long): ofLong

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

  133. def reverseMapShort(f: (Boolean) ⇒ Short): ofShort

  134. def reverse_:::(prefix: ofBoolean): ofBoolean

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

  136. def scanLeft1(f: (Boolean, Boolean) ⇒ Boolean): ofBoolean

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

  138. def scanLeftByte(z: Byte)(f: (Byte, Boolean) ⇒ Byte): ofByte

  139. def scanLeftChar(z: Char)(f: (Char, Boolean) ⇒ Char): ofChar

  140. def scanLeftDouble(z: Double)(f: (Double, Boolean) ⇒ Double): ofDouble

  141. def scanLeftFloat(z: Float)(f: (Float, Boolean) ⇒ Float): ofFloat

  142. def scanLeftInt(z: Int)(f: (Int, Boolean) ⇒ Int): ofInt

  143. def scanLeftLong(z: Long)(f: (Long, Boolean) ⇒ Long): ofLong

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

  145. def scanLeftShort(z: Short)(f: (Short, Boolean) ⇒ Short): ofShort

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

  147. def scanRight1(f: (Boolean, Boolean) ⇒ Boolean): ofBoolean

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

  149. def scanRightByte(z: Byte)(f: (Boolean, Byte) ⇒ Byte): ofByte

  150. def scanRightChar(z: Char)(f: (Boolean, Char) ⇒ Char): ofChar

  151. def scanRightDouble(z: Double)(f: (Boolean, Double) ⇒ Double): ofDouble

  152. def scanRightFloat(z: Float)(f: (Boolean, Float) ⇒ Float): ofFloat

  153. def scanRightInt(z: Int)(f: (Boolean, Int) ⇒ Int): ofInt

  154. def scanRightLong(z: Long)(f: (Boolean, Long) ⇒ Long): ofLong

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

  156. def scanRightShort(z: Short)(f: (Boolean, Short) ⇒ Short): ofShort

  157. val self: Array[Boolean]

  158. def size: Int

  159. def slice(from: Int, until: Int): ofBoolean

  160. def sliding(_size: Int, step: Int = 1): Iterator[ofBoolean]

    Annotations
    @throws( ... )

  161. def span(f: (Boolean) ⇒ Boolean): (ofBoolean, ofBoolean)

  162. def splitAt(n: Int): (ofBoolean, ofBoolean)

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

  164. def tailOption: Option[ofBoolean]

  165. def tails: Iterator[ofBoolean]

  166. def take(n: Int): ofBoolean

  167. def takeRight(n: Int): ofBoolean

  168. def takeWhile(f: (Boolean) ⇒ Boolean): ofBoolean

  169. def takeWhileR(f: (Boolean) ⇒ Boolean): ofBoolean

  170. def toString(): String

    Definition Classes
    ofBoolean → Any

  171. def updated(index: Int, elem: Boolean): ofBoolean

    Annotations
    @throws( ... )

  172. def withFilter(f: (Boolean) ⇒ Boolean): WithFilterBoolean

Inherited from AnyVal

Inherited from Any

Ungrouped