Chunk

abstract def apply(n: Int): A

abstract def foreach(f: (A) ⇒ Unit): Unit

abstract def length: Int

The number of elements in the chunk.

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

final def !=(arg0: Any): Boolean

final def ##(): Int

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

Returns the concatenation of this chunk with the specified chunk.

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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

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

Drops the first n elements of the chunk.

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

Drops all elements so long as the predicate returns true.

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

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

Returns a filtered subset of this chunk.

def finalize(): Unit

def flatMap[B](f: (A) ⇒ Chunk[B]): Chunk[B]

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

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

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

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

Folds over the elements in this chunk from the left.

final def foldLeftLazy[S](z: S)(pred: (S) ⇒ Boolean)(f: (S, A) ⇒ S): S

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

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

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

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

Folds over the elements in this chunk from the right.

final def getClass(): Class[_]

final def hashCode(): Int

final def isEmpty: Boolean

Determines if the chunk is empty.

final def isInstanceOf[T0]: Boolean

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

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

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

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

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

Effectfully maps the elements of this chunk.

final def mapM_[R, E](f: (A) ⇒ ZIO[R, E, _]): ZIO[R, E, Unit]

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

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

Materializes a chunk into a chunk backed by an array.

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

final def notEmpty: Boolean

Determines if the chunk is not empty.

final def notify(): Unit

final def notifyAll(): Unit

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

Returns two splits of this chunk at the specified index.

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

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

Takes the first n elements of the chunk.

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

Takes all elements so long as the predicate returns true.

def toArray[A1 >: A]: Array[A1]

Converts the chunk into an array.

def toSeq: Seq[A]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

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

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

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

Zips this chunk with the index of every element.

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

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

final def traverse[R, E, B](f: (A) ⇒ ZIO[R, E, B]): ZIO[R, E, Chunk[B]]

Effectfully traverses the elements of this chunk.

final def traverse_[R, E](f: (A) ⇒ ZIO[R, E, _]): ZIO[R, E, Unit]

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