Class/Object

nobox

ofBoolean

Related Docs: object ofBoolean | package nobox

Permalink

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
Visibility
  1. Public
  2. All

Instance Constructors

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

    Permalink

Value Members

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

    Permalink
    Definition Classes
    Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    Any
  3. def ++(that: ofBoolean): ofBoolean

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

    Permalink
    Definition Classes
    Any
  5. def ===(that: ofBoolean): Boolean

    Permalink
    Annotations
    @inline()
  6. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Permalink
  7. final def asInstanceOf[T0]: T0

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

    Permalink

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

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

    Permalink

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

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

    Permalink

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

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

    Permalink

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

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

    Permalink

    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]

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

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

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

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

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

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

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

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

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

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

    Permalink

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

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

    Permalink

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

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

    Permalink

    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]

    Permalink

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

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

    Permalink

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

  28. def contains(elem: Boolean): Boolean

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

    Permalink
  30. def deleteFirst(elem: Boolean): ofBoolean

    Permalink
  31. def drop(n: Int): ofBoolean

    Permalink
  32. def dropRight(n: Int): ofBoolean

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Permalink
    Definition Classes
    AnyVal → Any
  93. def groupBy[A](f: (Boolean) ⇒ A): Map[A, ofBoolean]

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

    Permalink
    Annotations
    @throws( ... )
  95. def indexOf(elem: Boolean): Option[Int]

    Permalink
  96. def initOption: Option[ofBoolean]

    Permalink
  97. def inits: Iterator[ofBoolean]

    Permalink
  98. def interleave(that: ofBoolean): ofBoolean

    Permalink
  99. def intersperse(a: Boolean): ofBoolean

    Permalink
  100. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  101. def lastIndexOf(elem: Boolean): Option[Int]

    Permalink
  102. def length: Int

    Permalink
    Annotations
    @inline()
  103. def map[A](f: (Boolean) ⇒ A)(implicit A: ClassTag[A]): Array[A]

    Permalink
  104. def mapBoolean(f: (Boolean) ⇒ Boolean): ofBoolean

    Permalink
  105. def mapByte(f: (Boolean) ⇒ Byte): ofByte

    Permalink
  106. def mapChar(f: (Boolean) ⇒ Char): ofChar

    Permalink
  107. def mapDouble(f: (Boolean) ⇒ Double): ofDouble

    Permalink
  108. def mapFloat(f: (Boolean) ⇒ Float): ofFloat

    Permalink
  109. def mapInt(f: (Boolean) ⇒ Int): ofInt

    Permalink
  110. def mapLong(f: (Boolean) ⇒ Long): ofLong

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

    Permalink
  112. def mapShort(f: (Boolean) ⇒ Short): ofShort

    Permalink
  113. def max: Option[Boolean]

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

    Permalink
  115. def min: Option[Boolean]

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

    Permalink
  117. def minmax: Option[(Boolean, Boolean)]

    Permalink
  118. def mkString: String

    Permalink
  119. def mkString(sep: String): String

    Permalink
  120. def mkString(start: String, sep: String, end: String): String

    Permalink
  121. def partition(f: (Boolean) ⇒ Boolean): (ofBoolean, ofBoolean)

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

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

    Permalink
  124. def reverse: ofBoolean

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

    Permalink
  126. def reverseMapBoolean(f: (Boolean) ⇒ Boolean): ofBoolean

    Permalink
  127. def reverseMapByte(f: (Boolean) ⇒ Byte): ofByte

    Permalink
  128. def reverseMapChar(f: (Boolean) ⇒ Char): ofChar

    Permalink
  129. def reverseMapDouble(f: (Boolean) ⇒ Double): ofDouble

    Permalink
  130. def reverseMapFloat(f: (Boolean) ⇒ Float): ofFloat

    Permalink
  131. def reverseMapInt(f: (Boolean) ⇒ Int): ofInt

    Permalink
  132. def reverseMapLong(f: (Boolean) ⇒ Long): ofLong

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

    Permalink
  134. def reverseMapShort(f: (Boolean) ⇒ Short): ofShort

    Permalink
  135. def reverse_:::(prefix: ofBoolean): ofBoolean

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

    Permalink
  137. def scanLeft1(f: (Boolean, Boolean) ⇒ Boolean): ofBoolean

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

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

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

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

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

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

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

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

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

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

    Permalink
  148. def scanRight1(f: (Boolean, Boolean) ⇒ Boolean): ofBoolean

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

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

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

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

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

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

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

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

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

    Permalink
  158. val self: Array[Boolean]

    Permalink
  159. def size: Int

    Permalink
    Annotations
    @inline()
  160. def slice(from: Int, until: Int): ofBoolean

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

    Permalink
    Annotations
    @throws( ... )
  162. def span(f: (Boolean) ⇒ Boolean): (ofBoolean, ofBoolean)

    Permalink
  163. def splitAt(n: Int): (ofBoolean, ofBoolean)

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

    Permalink
  165. def tailOption: Option[ofBoolean]

    Permalink
  166. def tails: Iterator[ofBoolean]

    Permalink
  167. def take(n: Int): ofBoolean

    Permalink
  168. def takeRight(n: Int): ofBoolean

    Permalink
  169. def takeWhile(f: (Boolean) ⇒ Boolean): ofBoolean

    Permalink
  170. def takeWhileR(f: (Boolean) ⇒ Boolean): ofBoolean

    Permalink
  171. def toArray: Array[Boolean]

    Permalink
  172. def toList: List[Boolean]

    Permalink
  173. def toString(): String

    Permalink
    Definition Classes
    ofBoolean → Any
  174. def updated(index: Int, elem: Boolean): ofBoolean

    Permalink
    Annotations
    @throws( ... )
  175. def withFilter(f: (Boolean) ⇒ Boolean): WithFilterBoolean

    Permalink

Inherited from AnyVal

Inherited from Any

Ungrouped