NonEmptyChunk

abstract def apply(i: Int): A

Gets the i-th element of this chunk, throwing an IndexOutOfBoundsException if the index is not in the range [0,size).

abstract def copyToArray[B >: A](xs: Array[B], start: Int = 0): Unit

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

abstract def drop(n: Int): Chunk[A]

Returns a new chunk made up of the elemenets of this chunk without the first n elements.

abstract def filter(f: (A) ⇒ Boolean): Chunk[A]

Returns a new chunk made up of the elements of this chunk for which the specified predicate returns true.

abstract def foldLeft[B](z: B)(f: (B, A) ⇒ B): B

Reduces this chunk to a value of type B by applying f to each element, left to right, passing the output of each invocation of f to the next invocation of f and starting with z.

abstract def foldRight[B](z: B)(f: (A, B) ⇒ B): B

Reduces this chunk to a value of type B by applying f to each element, right to left, passing the output of each invocation of f to the next invocation of f and starting with z.

abstract def size: Int

Returns the number of elements in this chunk.

abstract def take(n: Int): Chunk[A]

Returns a new chunk made up of the first n elemenets of this chunk.

abstract def unconsNonEmpty: (A, Chunk[A])

Like uncons but returns the head and tail directly instead of being wrapped in an Option.

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect[B](pf: PartialFunction[A, B]): Chunk[B]

Maps and filters this chunk simultaneously using the supplied partial function.

def ensuring(cond: (NonEmptyChunk[A]) ⇒ Boolean, msg: ⇒ Any): NonEmptyChunk[A]

def ensuring(cond: (NonEmptyChunk[A]) ⇒ Boolean): NonEmptyChunk[A]

def ensuring(cond: Boolean, msg: ⇒ Any): NonEmptyChunk[A]

def ensuring(cond: Boolean): NonEmptyChunk[A]

final def eq(arg0: AnyRef): Boolean

def equals(a: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def head: A

Returns the first element in the chunk.

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

Returns the index of the first element for which p returns true.

def isEmpty: Boolean

Returns true if this chunk has no elements.

final def isInstanceOf[T0]: Boolean

def iterator: Iterator[A]

Creates an iterator that iterates the elements of this chunk.

def last: A

Returns the last element in the chunk.

def map[B](f: (A) ⇒ B): NonEmptyChunk[B]

Applies f to each element of this chunk, resulting in a new chunk of the same size.

def mapAccumulate[S, B](s0: S)(f: (S, A) ⇒ (S, B)): (S, NonEmptyChunk[B])

Simultaneously folds and maps this chunk, returning the output of the fold and the transformed chunk.

final def ne(arg0: AnyRef): Boolean

def nonEmpty: Boolean

Returns true if this chunk has at least 1 element.

final def notify(): Unit

final def notifyAll(): Unit

def reduceLeft[A2 >: A](f: (A2, A) ⇒ A2): A2

Like foldLeft but uses the first element of the chunk as the starting value.

def reduceRight[A2 >: A](f: (A, A2) ⇒ A2): A2

Like foldRight but uses the first element of the chunk as the starting value.

def scanLeft[B](z: B)(f: (B, A) ⇒ B): NonEmptyChunk[B]

Like foldLeft but each intermediate B value is output.

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

def tail: Chunk[A]

Returns the all but the first element of the chunk.

def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

Copies the elements of this chunk to an array.

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

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

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

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

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

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

def toList: List[A]

Converts this chunk to a list.

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

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

def toString(): String

def toVector: Vector[A]

Converts this chunk to a vector.

def uncons: Option[(A, Chunk[A])]

If this chunk is non-empty, returns the first element of the chunk and the rest as a new chunk.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (NonEmptyChunk[A], B)