ByteArray

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++[A1 >: Byte](that: NonEmptyChunk[A1]): NonEmptyChunk[A1]

final def ++[A1 >: Byte](that: Chunk[A1]): Chunk[A1]

Returns the concatenation of this chunk with the specified chunk.

def ++[B >: Byte, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def ++:[B >: Byte, That](that: Traversable[B])(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def ++:[B >: Byte, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

final def +:[A1 >: Byte, That](a1: A1)(implicit bf: CanBuildFrom[Chunk[Byte], A1, That]): That

def /:[B](z: B)(op: (B, Byte) ⇒ B): B

final def :+[A1 >: Byte, That](a1: A1)(implicit bf: CanBuildFrom[Chunk[Byte], A1, That]): That

def :\[B](z: B)(op: (Byte, B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

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

def aggregate[B](z: ⇒ B)(seqop: (B, Byte) ⇒ B, combop: (B, B) ⇒ B): B

def andThen[C](k: (Byte) ⇒ C): PartialFunction[Int, C]

def append[A1 >: Byte](a1: A1): Chunk[A1]

Appends an element to the chunk.

def apply(n: Int): Byte

def applyOrElse[A1 <: Int, B1 >: Byte](x: A1, default: (A1) ⇒ B1): B1

val array: Array[Byte]

def arrayIterator[A1 >: Byte]: Iterator[Array[A1]]

Returns an Iterator that iterates over the arrays underlying this Chunk.

final def asBits(implicit ev: <:<[Byte, Byte]): Chunk[Boolean]

Converts a chunk of bytes to a chunk of bits.

final def asInstanceOf[T0]: T0

def boolean(index: Int)(implicit ev: <:<[Byte, Boolean]): Boolean

Get the element at the specified index.

def byte(index: Int)(implicit ev: <:<[Byte, Byte]): Byte

Get the element at the specified index.

def canEqual(that: Any): Boolean

def char(index: Int)(implicit ev: <:<[Byte, Char]): Char

Get the element at the specified index.

implicit val classTag: ClassTag[Byte]

def clone(): AnyRef

final def collect[B, That](pf: PartialFunction[Byte, B])(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

Returns a filtered, mapped subset of the elements of this chunk.

def collectChunk[B](pf: PartialFunction[Byte, B]): Chunk[B]

Returns a filtered, mapped subset of the elements of this chunk.

def collectFirst[B](pf: PartialFunction[Byte, B]): Option[B]

def collectM[R, E, B](pf: PartialFunction[Byte, ZIO[R, E, B]]): ZIO[R, E, Chunk[B]]

Returns a filtered, mapped subset of the elements of this chunk based on a .

def collectWhile[B](pf: PartialFunction[Byte, B]): Chunk[B]

Transforms all elements of the chunk for as long as the specified partial function is defined.

def collectWhileM[R, E, B](pf: PartialFunction[Byte, ZIO[R, E, B]]): ZIO[R, E, Chunk[B]]

def combinations(n: Int): Iterator[Chunk[Byte]]

def companion: GenericCompanion[Chunk]

def compose[A](g: (A) ⇒ Int): (A) ⇒ Byte

def contains[A1 >: Byte](elem: A1): Boolean

def containsSlice[B](that: GenSeq[B]): Boolean

def copyToArray[B >: Byte](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: Byte](xs: Array[B]): Unit

def copyToArray[B >: Byte](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: Byte](dest: Buffer[B]): Unit

final def corresponds[B](that: Chunk[B])(f: (Byte, B) ⇒ Boolean): Boolean

Determines whether this chunk and the specified chunk have the same length and every pair of corresponding elements of this chunk and the specified chunk satisfy the specified predicate.

def corresponds[B](that: GenSeq[B])(p: (Byte, B) ⇒ Boolean): Boolean

def count(p: (Byte) ⇒ Boolean): Int

def depth: Int

def diff[B >: Byte](that: GenSeq[B]): Chunk[Byte]

def distinct: Chunk[Byte]

def double(index: Int)(implicit ev: <:<[Byte, Double]): Double

Get the element at the specified index.

def drop(n: Int): Chunk[Byte]

Drops the first n elements of the chunk.

def dropRight(n: Int): Chunk[Byte]

def dropWhile(f: (Byte) ⇒ Boolean): Chunk[Byte]

Drops all elements so long as the predicate returns true.

def dropWhileM[R, E](p: (Byte) ⇒ ZIO[R, E, Boolean]): ZIO[R, E, Chunk[Byte]]

def endsWith[B](that: GenSeq[B]): Boolean

final def eq(arg0: AnyRef): Boolean

final def equals(that: Any): Boolean

final def exists(f: (Byte) ⇒ Boolean): Boolean

Determines whether a predicate is satisfied for at least one element of this chunk.

def filter(f: (Byte) ⇒ Boolean): Chunk[Byte]

Returns a filtered subset of this chunk.

final def filterM[R, E](f: (Byte) ⇒ ZIO[R, E, Boolean]): ZIO[R, E, Chunk[Byte]]

Filters this chunk by the specified effectful predicate, retaining all elements for which the predicate evaluates to true.

def filterNot(p: (Byte) ⇒ Boolean): Chunk[Byte]

def finalize(): Unit

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

Returns the first element that satisfies the predicate.

final def flatMap[B, That](f: (Byte) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

Returns the concatenation of mapping every element into a new chunk using the specified function.

final def flatMapChunk[B, That](f: (Byte) ⇒ GenTraversableOnce[B]): Chunk[B]

The implementation of flatMap for Chunk.

final def flatten[B](implicit ev: <:<[Byte, Chunk[B]]): Chunk[B]

Flattens a chunk of chunks into a single chunk by concatenating all chunks.

def flatten[B](implicit asTraversable: (Byte) ⇒ GenTraversableOnce[B]): Chunk[B]

def float(index: Int)(implicit ev: <:<[Byte, Float]): Float

Get the element at the specified index.

def fold[A1 >: Byte](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[S](s0: S)(f: (S, Byte) ⇒ S): S

Folds over the elements in this chunk from the left.

final def foldM[R, E, S](s: S)(f: (S, Byte) ⇒ ZIO[R, E, S]): ZIO[R, E, S]

Effectfully folds over the elements in this chunk from the left.

def foldRight[S](s0: S)(f: (Byte, S) ⇒ S): S

Folds over the elements in this chunk from the right.

final def foldWhile[S](s0: S)(pred: (S) ⇒ Boolean)(f: (S, Byte) ⇒ S): S

Folds over the elements in this chunk from the left.

final def foldWhileM[R, E, S](z: S)(pred: (S) ⇒ Boolean)(f: (S, Byte) ⇒ ZIO[R, E, S]): ZIO[R, E, S]

final def forall(f: (Byte) ⇒ Boolean): Boolean

Determines whether a predicate is satisfied for all elements of this chunk.

def foreach[B](f: (Byte) ⇒ B): Unit

def genericBuilder[B]: Builder[B, Chunk[B]]

final def getClass(): Class[_]

def groupBy[K](f: (Byte) ⇒ K): Map[K, Chunk[Byte]]

def grouped(size: Int): Iterator[Chunk[Byte]]

def hasDefiniteSize: Boolean

final def hashCode(): Int

def head: Byte

final def headOption: Option[Byte]

Returns the first element of this chunk if it exists.

def indexOf[B >: Byte](elem: B, from: Int): Int

def indexOf[B >: Byte](elem: B): Int

def indexOfSlice[B >: Byte](that: GenSeq[B], from: Int): Int

def indexOfSlice[B >: Byte](that: GenSeq[B]): Int

final def indexWhere(f: (Byte) ⇒ Boolean, from: Int): Int

Returns the first index for which the given predicate is satisfied after or at some given index.

final def indexWhere(f: (Byte) ⇒ Boolean): Int

Returns the first index for which the given predicate is satisfied.

def indices: Range

def init: Chunk[Byte]

def inits: Iterator[Chunk[Byte]]

def int(index: Int)(implicit ev: <:<[Byte, Int]): Int

Get the element at the specified index.

def intersect[B >: Byte](that: GenSeq[B]): Chunk[Byte]

def isDefinedAt(idx: Int): Boolean

final def isEmpty: Boolean

Determines if the chunk is empty.

final def isInstanceOf[T0]: Boolean

final def isTraversableAgain: Boolean

def iterator: Iterator[Byte]

def last: Byte

def lastIndexOf[B >: Byte](elem: B, end: Int): Int

def lastIndexOf[B >: Byte](elem: B): Int

def lastIndexOfSlice[B >: Byte](that: GenSeq[B], end: Int): Int

def lastIndexOfSlice[B >: Byte](that: GenSeq[B]): Int

def lastIndexWhere(p: (Byte) ⇒ Boolean, end: Int): Int

def lastIndexWhere(p: (Byte) ⇒ Boolean): Int

final def lastOption: Option[Byte]

Returns the last element of this chunk if it exists.

def left: Chunk[Byte]

val length: Int

def lengthCompare(len: Int): Int

def lift: (Int) ⇒ Option[Byte]

def long(index: Int)(implicit ev: <:<[Byte, Long]): Long

Get the element at the specified index.

final def map[B, That](f: (Byte) ⇒ B)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

Returns a chunk with the elements mapped by the specified function.

final def mapAccum[S1, B](s1: S1)(f1: (S1, Byte) ⇒ (S1, B)): (S1, Chunk[B])

Statefully maps over the chunk, producing new elements of type B.

final def mapAccumM[R, E, S1, B](s1: S1)(f1: (S1, Byte) ⇒ ZIO[R, E, (S1, B)]): ZIO[R, E, (S1, Chunk[B])]

Statefully and effectfully maps over the elements of this chunk to produce new elements.

def mapChunk[B](f: (Byte) ⇒ B): Chunk[B]

Returns a chunk with the elements mapped by the specified function.

final def mapM[R, E, B](f: (Byte) ⇒ ZIO[R, E, B]): ZIO[R, E, Chunk[B]]

Effectfully maps the elements of this chunk.

final def mapMPar[R, E, B](f: (Byte) ⇒ ZIO[R, E, B]): ZIO[R, E, Chunk[B]]

Effectfully maps the elements of this chunk in parallel.

final def mapMPar_[R, E](f: (Byte) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]

Effectfully maps the elements of this chunk in parallel purely for the effects.

final def mapM_[R, E](f: (Byte) ⇒ ZIO[R, E, Any]): ZIO[R, E, Unit]

Effectfully maps the elements of this chunk purely for the effects.

def materialize[A1 >: Byte]: Chunk[A1]

Materializes a chunk into a chunk backed by an array.

def max[B >: Byte](implicit cmp: Ordering[B]): Byte

def maxBy[B](f: (Byte) ⇒ B)(implicit cmp: Ordering[B]): Byte

def min[B >: Byte](implicit cmp: Ordering[B]): Byte

def minBy[B](f: (Byte) ⇒ B)(implicit cmp: Ordering[B]): Byte

final def mkString: String

Generates a readable string representation of this chunk.

final def mkString(sep: String): String

Generates a readable string representation of this chunk using the specified separator string.

final def mkString(start: String, sep: String, end: String): String

Generates a readable string representation of this chunk using the specified start, separator, and end strings.

final def ne(arg0: AnyRef): Boolean

def newBuilder: ChunkBuilder[Byte]

Constructs a new ChunkBuilder.

final def nonEmpty: Boolean

Determines if the chunk is not empty.

def nonEmptyOrElse[B](ifEmpty: ⇒ B)(fn: (NonEmptyChunk[Byte]) ⇒ B): B

Runs fn if a chunk is not empty or returns default value

final def notify(): Unit

final def notifyAll(): Unit

def orElse[A1 <: Int, B1 >: Byte](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

def padTo[B >: Byte, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def par: ParSeq[Byte]

def parCombiner: Combiner[Byte, ParSeq[Byte]]

def partition(p: (Byte) ⇒ Boolean): (Chunk[Byte], Chunk[Byte])

final def partitionMap[B, C](f: (Byte) ⇒ Either[B, C]): (Chunk[B], Chunk[C])

Partitions the elements of this chunk into two chunks using the specified function.

def patch[B >: Byte, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def permutations: Iterator[Chunk[Byte]]

def prefixLength(p: (Byte) ⇒ Boolean): Int

def prepend[A1 >: Byte](a1: A1): Chunk[A1]

Prepends an element to the chunk.

def product[B >: Byte](implicit num: Numeric[B]): B

def reduce[A1 >: Byte](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: Byte](op: (B, Byte) ⇒ B): B

def reduceLeftOption[B >: Byte](op: (B, Byte) ⇒ B): Option[B]

def reduceOption[A1 >: Byte](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: Byte](op: (Byte, B) ⇒ B): B

def reduceRightOption[B >: Byte](op: (Byte, B) ⇒ B): Option[B]

def repr: Chunk[Byte]

def reverse: Chunk[Byte]

def reverseArrayIterator[A1 >: Byte]: Iterator[Array[A1]]

Returns an Iterator that iterates over the arrays underlying this Chunk in reverse order.

def reverseIterator: Iterator[Byte]

def reverseMap[B, That](f: (Byte) ⇒ B)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def reversed: List[Byte]

def right: Chunk[Byte]

def runWith[U](action: (Byte) ⇒ U): (Int) ⇒ Boolean

def sameElements[B >: Byte](that: GenIterable[B]): Boolean

def scan[B >: Byte, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Chunk[Byte], B, That]): That

def scanLeft[B, That](z: B)(op: (B, Byte) ⇒ B)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def scanRight[B, That](z: B)(op: (Byte, B) ⇒ B)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def segmentLength(p: (Byte) ⇒ Boolean, from: Int): Int

def seq: IndexedSeq[Byte]

def short(index: Int)(implicit ev: <:<[Byte, Short]): Short

Get the element at the specified index.

final def size: Int

The number of elements in the chunk.

def slice(from: Int, until: Int): Chunk[Byte]

def sliding(size: Int, step: Int): Iterator[Chunk[Byte]]

def sliding(size: Int): Iterator[Chunk[Byte]]

def sortBy[B](f: (Byte) ⇒ B)(implicit ord: Ordering[B]): Chunk[Byte]

def sortWith(lt: (Byte, Byte) ⇒ Boolean): Chunk[Byte]

def sorted[B >: Byte](implicit ord: Ordering[B]): Chunk[Byte]

def span(p: (Byte) ⇒ Boolean): (Chunk[Byte], Chunk[Byte])

final def splitAt(n: Int): (Chunk[Byte], Chunk[Byte])

Returns two splits of this chunk at the specified index.

final def splitWhere(f: (Byte) ⇒ Boolean): (Chunk[Byte], Chunk[Byte])

Splits this chunk on the first element that matches this predicate.

def startsWith[B](that: GenSeq[B], offset: Int): Boolean

def startsWith[B](that: GenSeq[B]): Boolean

def stringPrefix: String

def sum[B >: Byte](implicit num: Numeric[B]): B

final def synchronized[T0](arg0: ⇒ T0): T0

def tail: Chunk[Byte]

def tails: Iterator[Chunk[Byte]]

def take(n: Int): Chunk[Byte]

Takes the first n elements of the chunk.

def takeRight(n: Int): Chunk[Byte]

def takeWhile(f: (Byte) ⇒ Boolean): Chunk[Byte]

Takes all elements so long as the predicate returns true.

def thisCollection: IndexedSeq[Byte]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Byte, Col[Byte]]): Col[Byte]

def toArray[A1 >: Byte](n: Int, dest: Array[A1]): Unit

def toArray[A1 >: Byte](implicit arg0: ClassTag[A1]): Array[A1]

Converts the chunk into an array.

final def toBinaryString(implicit ev: <:<[Byte, Boolean]): String

Renders this chunk of bits as a binary string.

def toBuffer[A1 >: Byte]: Buffer[A1]

def toCollection(repr: Chunk[Byte]): IndexedSeq[Byte]

def toIndexedSeq: IndexedSeq[Byte]

def toIterable: Iterable[Byte]

def toIterator: Iterator[Byte]

final def toList: List[Byte]

def toMap[T, U](implicit ev: <:<[Byte, (T, U)]): Map[T, U]

def toSeq: Seq[Byte]

def toSet[B >: Byte]: Set[B]

def toStream: Stream[Byte]

final def toString(): String

def toTraversable: Traversable[Byte]

final def toVector: Vector[Byte]

def transpose[B](implicit asTraversable: (Byte) ⇒ GenTraversableOnce[B]): Chunk[Chunk[B]]

def union[B >: Byte, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def unzip[A1, A2](implicit asPair: (Byte) ⇒ (A1, A2)): (Chunk[A1], Chunk[A2])

def unzip3[A1, A2, A3](implicit asTriple: (Byte) ⇒ (A1, A2, A3)): (Chunk[A1], Chunk[A2], Chunk[A3])

def updated[B >: Byte, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Chunk[Byte], B, That]): That

def view(from: Int, until: Int): SeqView[Byte, Chunk[Byte]]

def view: SeqView[Byte, Chunk[Byte]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withFilter(p: (Byte) ⇒ Boolean): FilterMonadic[Byte, Chunk[Byte]]

final def zip[B](that: Chunk[B]): Chunk[(Byte, B)]

Zips this chunk with the specified chunk to produce a new chunk with pairs of elements from each chunk.

def zip[A1 >: Byte, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Chunk[Byte], (A1, B), That]): That

final def zipAll[B](that: Chunk[B]): Chunk[(Option[Byte], Option[B])]

Zips this chunk with the specified chunk to produce a new chunk with pairs of elements from each chunk, filling in missing values from the shorter chunk with None.

def zipAll[B, A1 >: Byte, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Chunk[Byte], (A1, B), That]): That

final def zipAllWith[B, C](that: Chunk[B])(left: (Byte) ⇒ C, right: (B) ⇒ C)(both: (Byte, B) ⇒ C): Chunk[C]

Zips with chunk with the specified chunk to produce a new chunk with pairs of elements from each chunk combined using the specified function both.

final def zipWith[B, C](that: Chunk[B])(f: (Byte, B) ⇒ C): Chunk[C]

Zips this chunk with the specified chunk using the specified combiner.

final def zipWithIndex: Chunk[(Byte, Int)]

Zips this chunk with the index of every element.

def zipWithIndex[A1 >: Byte, That](implicit bf: CanBuildFrom[Chunk[Byte], (A1, Int), That]): That

final def zipWithIndexFrom(indexOffset: Int): Chunk[(Byte, Int)]

Zips this chunk with the index of every element, starting from the initial index value.

final def +[A1 >: Byte](a: A1): Chunk[A1]

Appends an element to the chunk