ofByte

Value Members

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

   

   Definition Classes

   Any

2. final def ##(): Int

   

   Definition Classes

   Any

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

   

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

   

   Definition Classes

   Any

5. def ===(that: ofByte): 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 collect[A](f: PartialFunction[Byte, A])(implicit A: ClassTag[A]): Array[A]

   

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

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

   

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

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

    

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

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

    

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

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

    

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

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

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

    

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

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

    

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

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

    

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

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

    

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

28. def contains(elem: Byte): Boolean

    

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

    

30. def deleteFirst(elem: Byte): ofByte

    

31. def drop(n: Int): ofByte

    

32. def dropRight(n: Int): ofByte

    

33. def dropWhile(f: (Byte) ⇒ Boolean): ofByte

    

34. def dropWhileR(f: (Byte) ⇒ Boolean): ofByte

    

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

    

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

    

37. def filter(f: (Byte) ⇒ Boolean): ofByte

    

38. def filterNot(f: (Byte) ⇒ Boolean): ofByte

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

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

    

    Definition Classes

    AnyVal → Any

93. def groupBy[A](f: (Byte) ⇒ A): Map[A, ofByte]

    

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

    

    Annotations

    @throws( ... )

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

    

96. def initOption: Option[ofByte]

    

97. def inits: Iterator[ofByte]

    

98. def interleave(that: ofByte): ofByte

    

99. def intersperse(a: Byte): ofByte

    

100. final def isInstanceOf[T0]: Boolean

     

     Definition Classes

     Any

101. def lastIndexOf(elem: Byte): Option[Int]

     

102. def length: Int

     

     Annotations

     @inline()

103. def map[A](f: (Byte) ⇒ A)(implicit A: ClassTag[A]): Array[A]

     

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

     

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

     

106. def mapChar(f: (Byte) ⇒ Char): ofChar

     

107. def mapDouble(f: (Byte) ⇒ Double): ofDouble

     

108. def mapFloat(f: (Byte) ⇒ Float): ofFloat

     

109. def mapInt(f: (Byte) ⇒ Int): ofInt

     

110. def mapLong(f: (Byte) ⇒ Long): ofLong

     

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

     

112. def mapShort(f: (Byte) ⇒ Short): ofShort

     

113. def max: Option[Byte]

     

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

     

115. def min: Option[Byte]

     

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

     

117. def minmax: Option[(Byte, Byte)]

     

118. def mkString: String

     

119. def mkString(sep: String): String

     

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

     

121. def partition(f: (Byte) ⇒ Boolean): (ofByte, ofByte)

     

122. def product: Int

     

123. def productDouble: Double

     

124. def productLong: Long

     

125. def reduceLeftOption(f: (Byte, Byte) ⇒ Byte): Option[Byte]

     

126. def reduceRightOption(f: (Byte, Byte) ⇒ Byte): Option[Byte]

     

127. def reverse: ofByte

     

128. def reverseMap[A](f: (Byte) ⇒ A)(implicit A: ClassTag[A]): Array[A]

     

129. def reverseMapBoolean(f: (Byte) ⇒ Boolean): ofBoolean

     

130. def reverseMapByte(f: (Byte) ⇒ Byte): ofByte

     

131. def reverseMapChar(f: (Byte) ⇒ Char): ofChar

     

132. def reverseMapDouble(f: (Byte) ⇒ Double): ofDouble

     

133. def reverseMapFloat(f: (Byte) ⇒ Float): ofFloat

     

134. def reverseMapInt(f: (Byte) ⇒ Int): ofInt

     

135. def reverseMapLong(f: (Byte) ⇒ Long): ofLong

     

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

     

137. def reverseMapShort(f: (Byte) ⇒ Short): ofShort

     

138. def reverse_:::(prefix: ofByte): ofByte

     

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

     

140. def scanLeft1(f: (Byte, Byte) ⇒ Byte): ofByte

     

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

     

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

     

143. def scanLeftChar(z: Char)(f: (Char, Byte) ⇒ Char): ofChar

     

144. def scanLeftDouble(z: Double)(f: (Double, Byte) ⇒ Double): ofDouble

     

145. def scanLeftFloat(z: Float)(f: (Float, Byte) ⇒ Float): ofFloat

     

146. def scanLeftInt(z: Int)(f: (Int, Byte) ⇒ Int): ofInt

     

147. def scanLeftLong(z: Long)(f: (Long, Byte) ⇒ Long): ofLong

     

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

     

149. def scanLeftShort(z: Short)(f: (Short, Byte) ⇒ Short): ofShort

     

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

     

151. def scanRight1(f: (Byte, Byte) ⇒ Byte): ofByte

     

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

     

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

     

154. def scanRightChar(z: Char)(f: (Byte, Char) ⇒ Char): ofChar

     

155. def scanRightDouble(z: Double)(f: (Byte, Double) ⇒ Double): ofDouble

     

156. def scanRightFloat(z: Float)(f: (Byte, Float) ⇒ Float): ofFloat

     

157. def scanRightInt(z: Int)(f: (Byte, Int) ⇒ Int): ofInt

     

158. def scanRightLong(z: Long)(f: (Byte, Long) ⇒ Long): ofLong

     

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

     

160. def scanRightShort(z: Short)(f: (Byte, Short) ⇒ Short): ofShort

     

161. val self: Array[Byte]

     

162. def size: Int

     

     Annotations

     @inline()

163. def slice(from: Int, until: Int): ofByte

     

164. def sliding(_size: Int, step: Int = 1): Iterator[ofByte]

     

     Annotations

     @throws( ... )

165. def sorted: ofByte

     

166. def span(f: (Byte) ⇒ Boolean): (ofByte, ofByte)

     

167. def splitAt(n: Int): (ofByte, ofByte)

     

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

     

169. def sum: Int

     

170. def tailOption: Option[ofByte]

     

171. def tails: Iterator[ofByte]

     

172. def take(n: Int): ofByte

     

173. def takeRight(n: Int): ofByte

     

174. def takeWhile(f: (Byte) ⇒ Boolean): ofByte

     

175. def takeWhileR(f: (Byte) ⇒ Boolean): ofByte

     

176. def toArray: Array[Byte]

     

177. def toList: List[Byte]

     

178. def toString(): String

     

     Definition Classes

     ofByte → Any

179. def updated(index: Int, elem: Byte): ofByte

     

     Annotations

     @throws( ... )

180. def withFilter(f: (Byte) ⇒ Boolean): WithFilterByte