Buffer

abstract def buffer(b: B): A

abstract def duplicate(b: B): B

abstract def get(b: B, dest: Array[C], offset: Int, length: Int): B

abstract def get(b: B, n: Int): C

abstract def readOnly(b: B): B

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Buffer[A, B, C], B)

final def ==(arg0: Any): Boolean

def apply(i: Int): C

Returns the element at the specified index.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[O2](pf: PartialFunction[C, O2]): Chunk[O2]

More efficient version of filter(pf.isDefinedAt).map(pf).

def copyToArray[O2 >: C](xs: Array[O2], start: Int): Unit

Copies the elements of this chunk in to the specified array at the specified start index.

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

Drops the first n elements of this chunk.

def elementClassTag: ClassTag[C]

def ensuring(cond: (Buffer[A, B, C]) ⇒ Boolean, msg: ⇒ Any): Buffer[A, B, C]

def ensuring(cond: (Buffer[A, B, C]) ⇒ Boolean): Buffer[A, B, C]

def ensuring(cond: Boolean, msg: ⇒ Any): Buffer[A, B, C]

def ensuring(cond: Boolean): Buffer[A, B, C]

final def eq(arg0: AnyRef): Boolean

def equals(a: Any): Boolean

def filter(p: (C) ⇒ Boolean): Chunk[C]

Returns a chunk that has only the elements that satisfy the supplied predicate.

def find(p: (C) ⇒ Boolean): Option[C]

Returns the first element for which the predicate returns true or None if no elements satisfy the predicate.

def flatMap[O2](f: (C) ⇒ Chunk[O2]): Chunk[O2]

Maps f over the elements of this chunk and concatenates the result.

def foldLeft[A](init: A)(f: (A, C) ⇒ A): A

Left-folds the elements of this chunk.

def forall(p: (C) ⇒ Boolean): Boolean

Returns true if the predicate passes for all elements.

def foreach(f: (C) ⇒ Unit): Unit

Invokes the supplied function for each element of this chunk.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def head: Option[C]

Gets the first element of this chunk.

def indexWhere(p: (C) ⇒ Boolean): Option[Int]

Returns the index of the first element which passes the specified predicate (i.e., p(i) == true) or None if no elements pass the predicate.

final def isEmpty: Boolean

True if size is zero, false otherwise.

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[C]

Creates an iterator that iterates the elements of this chunk.

def knownElementType[B](implicit classTag: ClassTag[B]): Boolean

Returns true if this chunk is known to have elements of type B.

def last: Option[C]

Gets the last element of this chunk.

def map[O2](f: (C) ⇒ O2): Chunk[O2]

Creates a new chunk by applying f to each element in this chunk.

def mapAccumulate[S, O2](init: S)(f: (S, C) ⇒ (S, O2)): (S, Chunk[O2])

Maps the supplied stateful function over each element, outputting the final state and the accumulated outputs.

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

False if size is zero, true otherwise.

final def notify(): Unit

final def notifyAll(): Unit

val offset: Int

def reverseIterator: Iterator[C]

Creates an iterator that iterates the elements of this chunk in reverse order.

def scanLeft[O2](z: O2)(f: (O2, C) ⇒ O2): Chunk[O2]

Like foldLeft but emits each intermediate result of f.

def scanLeftCarry[O2](z: O2)(f: (O2, C) ⇒ O2): (Chunk[O2], O2)

Like scanLeft except the final element is emitted as a standalone value instead of as the last element of the accumulated chunk.

def scanLeft_[O2](z: O2, emitFinal: Boolean)(f: (O2, C) ⇒ O2): (Chunk[O2], O2)

val size: Int

Returns the number of elements in this chunk.

def splitAt(n: Int): (Chunk[C], Chunk[C])

Splits this chunk in to two chunks at the specified index.

def splitAtChunk_(n: Int): (A, A)

Splits this chunk in to two chunks at the specified index n, which is guaranteed to be in-bounds.

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

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

Takes the first n elements of this chunk.

def toArray[O2 >: C](implicit arg0: ClassTag[O2]): Array[O2]

Copies the elements of this chunk to an array.

def toBooleans[B >: C](implicit ev: =:=[B, Boolean]): Booleans

Converts this chunk to a Chunk.Booleans, allowing access to the underlying array of elements.

def toByteBuffer[B >: C](implicit ev: =:=[B, Byte]): java.nio.ByteBuffer

Converts this chunk to a java.nio.ByteBuffer.

def toBytes[B >: C](implicit ev: =:=[B, Byte]): Bytes

Converts this chunk to a Chunk.Bytes, allowing access to the underlying array of elements.

def toChain: Chain[C]

Converts this chunk to a chain.

def toDoubles[B >: C](implicit ev: =:=[B, Double]): Doubles

Converts this chunk to a Chunk.Doubles, allowing access to the underlying array of elements.

def toFloats[B >: C](implicit ev: =:=[B, Float]): Floats

Converts this chunk to a Chunk.Floats, allowing access to the underlying array of elements.

def toInts[B >: C](implicit ev: =:=[B, Int]): Ints

Converts this chunk to a Chunk.Ints, allowing access to the underlying array of elements.

def toList: List[C]

Converts this chunk to a list.

def toLongs[B >: C](implicit ev: =:=[B, Long]): Longs

Converts this chunk to a Chunk.Longs, allowing access to the underlying array of elements.

def toShorts[B >: C](implicit ev: =:=[B, Short]): Shorts

Converts this chunk to a Chunk.Shorts, allowing access to the underlying array of elements.

def toString(): String

def toVector: Vector[C]

Converts this chunk to a vector.

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def zip[O2](that: Chunk[O2]): Chunk[(C, O2)]

Zips this chunk the the supplied chunk, returning a chunk of tuples.

def zipWith[O2, O3](that: Chunk[O2])(f: (C, O2) ⇒ O3): Chunk[O3]

Zips this chunk with the supplied chunk, passing each pair to f, resulting in an output chunk.

def →[B](y: B): (Buffer[A, B, C], B)

def finalize(): Unit