NonEmptyChunk

final def !=(arg0: Any): Boolean

final def ##(): Int

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

Appends the specified Chunk to the end of this NonEmptyChunk.

def +:[A1 >: A](a: A1): NonEmptyChunk[A1]

A symbolic alias for prepended.

def :+[A1 >: A](a: A1): NonEmptyChunk[A1]

A symbolic alias for appended.

final def ==(arg0: Any): Boolean

def append[A1 >: A](that: Chunk[A1]): NonEmptyChunk[A1]

A named alias for ++.

def appended[A1 >: A](a: A1): NonEmptyChunk[A1]

Appends a single element to the end of this NonEmptyChunk.

def asBits(implicit ev: <:<[A, Byte]): NonEmptyChunk[Boolean]

Converts this NonEmptyChunk of bytes to a NonEmptyChunk of bits.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

Returns whether this NonEmptyChunk and the specified NonEmptyChunk are equal to each other.

def finalize(): Unit

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

Maps each element of this NonEmptyChunk to a new NonEmptyChunk and then concatenates them together.

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

Flattens a NonEmptyChunk of NonEmptyChunk values to a single NonEmptyChunk.

final def getClass(): Class[_]

def hashCode(): Int

Returns the hashcode of this NonEmptyChunk.

final def isInstanceOf[T0]: Boolean

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

Transforms the elements of this NonEmptyChunk with the specified function.

def mapAccum[S, B](s: S)(f: (S, A) ⇒ (S, B)): (S, NonEmptyChunk[B])

Maps over the elements of this NonEmptyChunk, maintaining some state along the way.

def mapAccumZIO[R, E, S, B](s: S)(f: (S, A) ⇒ ZIO[R, E, (S, B)])(implicit trace: ZTraceElement): ZIO[R, E, (S, NonEmptyChunk[B])]

Effectfully maps over the elements of this NonEmptyChunk, maintaining some state along the way.

def mapZIO[R, E, B](f: (A) ⇒ ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[B]]

Effectfully maps the elements of this NonEmptyChunk.

def mapZIOPar[R, E, B](f: (A) ⇒ ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[B]]

Effectfully maps the elements of this NonEmptyChunk in parallel.

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

Materialize the elements of this NonEmptyChunk into a NonEmptyChunk backed by an array.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prepend[A1 >: A](that: Chunk[A1]): NonEmptyChunk[A1]

Prepends the specified Chunk to the beginning of this NonEmptyChunk.

def prepended[A1 >: A](a: A1): NonEmptyChunk[A1]

Prepends a single element to the beginning of this NonEmptyChunk.

def reduceMapLeft[B](map: (A) ⇒ B)(reduce: (B, A) ⇒ B): B

Reduces the elements of this NonEmptyChunk from left to right using the function map to transform the first value to the type B and then the function reduce to combine the B value with each other A value.

def reduceMapRight[B](map: (A) ⇒ B)(reduce: (A, B) ⇒ B): B

Reduces the elements of this NonEmptyChunk from right to left using the function map to transform the first value to the type B and then the function reduce to combine the B value with each other A value.

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

def toChunk: Chunk[A]

Converts this NonEmptyChunk to a Chunk, discarding information about it not being empty.

def toCons[A1 >: A]: ::[A1]

Converts this NonEmptyChunk to the :: case of a List.

def toString(): String

Renders this NonEmptyChunk as a String.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[B](that: NonEmptyChunk[B])(implicit zippable: Zippable[A, B]): NonEmptyChunk[Out]

Zips this NonEmptyChunk with the specified NonEmptyChunk, only keeping as many elements as are in the smaller chunk.

def zipAll[B](that: Chunk[B]): NonEmptyChunk[(Option[A], Option[B])]

Zips this NonEmptyChunk with the specified Chunk, using None to "fill in" missing values if one chunk has fewer elements than the other.

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

Zips this NonEmptyChunk with the specified Chunk, using the specified functions to "fill in" missing values if one chunk has fewer elements than the other.

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

Zips this NonEmptyChunk with the specified NonEmptyChunk, only keeping as many elements as are in the smaller chunk.

def zipWithIndex: NonEmptyChunk[(A, Int)]

Annotates each element of this NonEmptyChunk with its index.

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

Annotates each element of this NonEmptyChunk with its index, with the specified offset.

def mapAccumM[R, E, S, B](s: S)(f: (S, A) ⇒ ZIO[R, E, (S, B)])(implicit trace: ZTraceElement): ZIO[R, E, (S, NonEmptyChunk[B])]

Effectfully maps over the elements of this NonEmptyChunk, maintaining some state along the way.

def mapM[R, E, B](f: (A) ⇒ ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[B]]

Effectfully maps the elements of this NonEmptyChunk.

def mapMPar[R, E, B](f: (A) ⇒ ZIO[R, E, B])(implicit trace: ZTraceElement): ZIO[R, E, NonEmptyChunk[B]]

Effectfully maps the elements of this NonEmptyChunk in parallel.