nobox
API
Generated with
nobox/nobox/ofByte

ofByte

nobox.ofByte
See theofByte companion object
final class ofByte(val self: Array[Byte]) extends AnyVal

Attributes

Companion
object
Graph
Supertypes
class AnyVal
trait Matchable
class Any

Members list

Value members

Concrete methods

def ++(that: ofByte): ofByte
def ===(that: ofByte): Boolean
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

def collectFirst[A](f: PartialFunction[Byte, A])(implicit A: ClassTag[A]): Option[A]
def collectFirstBoolean(f: PartialFunction[Byte, Boolean]): Option[Boolean]
def collectFirstByte(f: PartialFunction[Byte, Byte]): Option[Byte]
def collectFirstChar(f: PartialFunction[Byte, Char]): Option[Char]
def collectFirstDouble(f: PartialFunction[Byte, Double]): Option[Double]
def collectFirstFloat(f: PartialFunction[Byte, Float]): Option[Float]
def collectFirstInt(f: PartialFunction[Byte, Int]): Option[Int]
def collectFirstLong(f: PartialFunction[Byte, Long]): Option[Long]
def collectFirstRef[Y <: AnyRef : ClassTag](f: PartialFunction[Byte, Y]): Option[Y]
def collectFirstShort(f: PartialFunction[Byte, Short]): Option[Short]
def collectFloat(f: PartialFunction[Byte, Float]): ofFloat

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

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

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

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

Attributes

def contains(elem: Byte): Boolean
def count(f: Byte => Boolean): Int
def deleteFirst(elem: Byte): ofByte
def drop(n: Int): ofByte
def dropRight(n: Int): ofByte
def dropWhile(f: Byte => Boolean): ofByte
def dropWhileR(f: Byte => Boolean): ofByte
def endsWith(that: Array[Byte]): Boolean
def exists(f: Byte => Boolean): Boolean
def filter(f: Byte => Boolean): ofByte
def filterNot(f: Byte => Boolean): ofByte
def find(f: Byte => Boolean): Option[Byte]
def flatMap[A](f: Byte => Array[A])(implicit A: ClassTag[A]): Array[A]
def flatMapBoolean(f: Byte => Array[Boolean]): ofBoolean
def flatMapByte(f: Byte => Array[Byte]): ofByte
def flatMapChar(f: Byte => Array[Char]): ofChar
def flatMapDouble(f: Byte => Array[Double]): ofDouble
def flatMapFloat(f: Byte => Array[Float]): ofFloat
def flatMapInt(f: Byte => Array[Int]): ofInt
def flatMapLong(f: Byte => Array[Long]): ofLong
def flatMapRef[Y <: AnyRef : ClassTag](f: Byte => Array[Y]): ofRef[Y]
def flatMapShort(f: Byte => Array[Short]): ofShort
def foldLeft[A](z: A)(f: (A, Byte) => A)(implicit A: ClassTag[A]): A
def foldLeftBoolean(z: Boolean)(f: (Boolean, Byte) => Boolean): Boolean
def foldLeftByte(z: Byte)(f: (Byte, Byte) => Byte): Byte
def foldLeftChar(z: Char)(f: (Char, Byte) => Char): Char
def foldLeftDouble(z: Double)(f: (Double, Byte) => Double): Double
def foldLeftFloat(z: Float)(f: (Float, Byte) => Float): Float
def foldLeftInt(z: Int)(f: (Int, Byte) => Int): Int
def foldLeftLong(z: Long)(f: (Long, Byte) => Long): Long
def foldLeftRef[Y](z: Y)(f: (Y, Byte) => Y): Y
def foldLeftShort(z: Short)(f: (Short, Byte) => Short): Short
def foldMapLeft1[A](z: Byte => A)(f: (A, Byte) => A)(implicit A: ClassTag[A]): Option[A]
def foldMapLeft1Boolean(z: Byte => Boolean)(f: (Boolean, Byte) => Boolean): Option[Boolean]
def foldMapLeft1Byte(z: Byte => Byte)(f: (Byte, Byte) => Byte): Option[Byte]
def foldMapLeft1Char(z: Byte => Char)(f: (Char, Byte) => Char): Option[Char]
def foldMapLeft1Double(z: Byte => Double)(f: (Double, Byte) => Double): Option[Double]
def foldMapLeft1Float(z: Byte => Float)(f: (Float, Byte) => Float): Option[Float]
def foldMapLeft1Int(z: Byte => Int)(f: (Int, Byte) => Int): Option[Int]
def foldMapLeft1Long(z: Byte => Long)(f: (Long, Byte) => Long): Option[Long]
def foldMapLeft1Ref[Y](z: Byte => Y)(f: (Y, Byte) => Y): Option[Y]
def foldMapLeft1Short(z: Byte => Short)(f: (Short, Byte) => Short): Option[Short]
def foldMapRight1[A](z: Byte => A)(f: (Byte, A) => A)(implicit A: ClassTag[A]): Option[A]
def foldMapRight1Boolean(z: Byte => Boolean)(f: (Byte, Boolean) => Boolean): Option[Boolean]
def foldMapRight1Byte(z: Byte => Byte)(f: (Byte, Byte) => Byte): Option[Byte]
def foldMapRight1Char(z: Byte => Char)(f: (Byte, Char) => Char): Option[Char]
def foldMapRight1Double(z: Byte => Double)(f: (Byte, Double) => Double): Option[Double]
def foldMapRight1Float(z: Byte => Float)(f: (Byte, Float) => Float): Option[Float]
def foldMapRight1Int(z: Byte => Int)(f: (Byte, Int) => Int): Option[Int]
def foldMapRight1Long(z: Byte => Long)(f: (Byte, Long) => Long): Option[Long]
def foldMapRight1Ref[Y](z: Byte => Y)(f: (Byte, Y) => Y): Option[Y]
def foldMapRight1Short(z: Byte => Short)(f: (Byte, Short) => Short): Option[Short]
def foldRight[A](z: A)(f: (Byte, A) => A)(implicit A: ClassTag[A]): A
def foldRightBoolean(z: Boolean)(f: (Byte, Boolean) => Boolean): Boolean
def foldRightByte(z: Byte)(f: (Byte, Byte) => Byte): Byte
def foldRightChar(z: Char)(f: (Byte, Char) => Char): Char
def foldRightDouble(z: Double)(f: (Byte, Double) => Double): Double
def foldRightFloat(z: Float)(f: (Byte, Float) => Float): Float
def foldRightInt(z: Int)(f: (Byte, Int) => Int): Int
def foldRightLong(z: Long)(f: (Byte, Long) => Long): Long
def foldRightRef[Y](z: Y)(f: (Byte, Y) => Y): Y
def foldRightShort(z: Short)(f: (Byte, Short) => Short): Short
def forall(f: Byte => Boolean): Boolean
def foreach[U](f: Byte => U): Unit
def groupBy[A](f: Byte => A): Map[A, ofByte]
def grouped(n: Int): Iterator[ofByte]
def indexOf(elem: Byte): Option[Int]
def initOption: Option[ofByte]
def inits: Iterator[ofByte]
def interleave(that: ofByte): ofByte
def intersperse(a: Byte): ofByte
def lastIndexOf(elem: Byte): Option[Int]
def length: Int
def map[A](f: Byte => A)(implicit A: ClassTag[A]): Array[A]
def mapBoolean(f: Byte => Boolean): ofBoolean
def mapByte(f: Byte => Byte): ofByte
def mapChar(f: Byte => Char): ofChar
def mapDouble(f: Byte => Double): ofDouble
def mapFloat(f: Byte => Float): ofFloat
def mapInt(f: Byte => Int): ofInt
def mapLong(f: Byte => Long): ofLong
def mapRef[Y <: AnyRef : ClassTag](f: Byte => Y): ofRef[Y]
def mapShort(f: Byte => Short): ofShort
def max: Option[Byte]
def maxBy[A](f: Byte => A)(implicit A: Ordering[A]): Option[Byte]
def min: Option[Byte]
def minBy[A](f: Byte => A)(implicit A: Ordering[A]): Option[Byte]
def minmax: Option[(Byte, Byte)]
def mkString(start: String, sep: String, end: String): String
def mkString(sep: String): String
def mkString: String
def partition(f: Byte => Boolean): (ofByte, ofByte)
def product: Int
def productDouble: Double
def productLong: Long
def reduceLeftOption(f: (Byte, Byte) => Byte): Option[Byte]
def reduceRightOption(f: (Byte, Byte) => Byte): Option[Byte]
def reverseMap[A](f: Byte => A)(implicit A: ClassTag[A]): Array[A]
def reverseMapBoolean(f: Byte => Boolean): ofBoolean
def reverseMapByte(f: Byte => Byte): ofByte
def reverseMapChar(f: Byte => Char): ofChar
def reverseMapDouble(f: Byte => Double): ofDouble
def reverseMapFloat(f: Byte => Float): ofFloat
def reverseMapInt(f: Byte => Int): ofInt
def reverseMapLong(f: Byte => Long): ofLong
def reverseMapRef[Y <: AnyRef : ClassTag](f: Byte => Y): ofRef[Y]
def reverseMapShort(f: Byte => Short): ofShort
def reverse_:::(prefix: ofByte): ofByte
def scanLeft[A](z: A)(f: (A, Byte) => A)(implicit A: ClassTag[A]): Array[A]
def scanLeft1(f: (Byte, Byte) => Byte): ofByte
def scanLeftBoolean(z: Boolean)(f: (Boolean, Byte) => Boolean): ofBoolean
def scanLeftByte(z: Byte)(f: (Byte, Byte) => Byte): ofByte
def scanLeftChar(z: Char)(f: (Char, Byte) => Char): ofChar
def scanLeftDouble(z: Double)(f: (Double, Byte) => Double): ofDouble
def scanLeftFloat(z: Float)(f: (Float, Byte) => Float): ofFloat
def scanLeftInt(z: Int)(f: (Int, Byte) => Int): ofInt
def scanLeftLong(z: Long)(f: (Long, Byte) => Long): ofLong
def scanLeftRef[Y <: AnyRef : ClassTag](z: Y)(f: (Y, Byte) => Y): ofRef[Y]
def scanLeftShort(z: Short)(f: (Short, Byte) => Short): ofShort
def scanRight[A](z: A)(f: (Byte, A) => A)(implicit A: ClassTag[A]): Array[A]
def scanRight1(f: (Byte, Byte) => Byte): ofByte
def scanRightBoolean(z: Boolean)(f: (Byte, Boolean) => Boolean): ofBoolean
def scanRightByte(z: Byte)(f: (Byte, Byte) => Byte): ofByte
def scanRightChar(z: Char)(f: (Byte, Char) => Char): ofChar
def scanRightDouble(z: Double)(f: (Byte, Double) => Double): ofDouble
def scanRightFloat(z: Float)(f: (Byte, Float) => Float): ofFloat
def scanRightInt(z: Int)(f: (Byte, Int) => Int): ofInt
def scanRightLong(z: Long)(f: (Byte, Long) => Long): ofLong
def scanRightRef[Y <: AnyRef : ClassTag](z: Y)(f: (Byte, Y) => Y): ofRef[Y]
def scanRightShort(z: Short)(f: (Byte, Short) => Short): ofShort
def size: Int
def slice(from: Int, until: Int): ofByte
def sliding(_size: Int, step: Int): Iterator[ofByte]
def sorted: ofByte
def span(f: Byte => Boolean): (ofByte, ofByte)
def splitAt(n: Int): (ofByte, ofByte)
def startsWith(that: Array[Byte], offset: Int): Boolean
def sum: Int
def tailOption: Option[ofByte]
def tails: Iterator[ofByte]
def take(n: Int): ofByte
def takeRight(n: Int): ofByte
def takeWhile(f: Byte => Boolean): ofByte
def takeWhileR(f: Byte => Boolean): ofByte
def toArray: Array[Byte]
def toList: List[Byte]
override def toString: String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns

a string representation of the object.

Definition Classes
Any
def updated(index: Int, elem: Byte): ofByte
def withFilter(f: Byte => Boolean): WithFilterByte

Concrete fields

val self: Array[Byte]
Generated with