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(scala.this.throws.<init>$default$1[IllegalArgumentException])

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(scala.this.throws.<init>$default$1[IllegalArgumentException])

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(scala.this.throws.<init>$default$1[IndexOutOfBoundsException])

180.  def withFilter(f: (Byte) => Boolean): WithFilterByte