Packages

final class NonEmptyChunk[+A] extends NonEmptySeq[A, NonEmptyChunk, Chunk] with Serializable

A NonEmptyChunk is a Chunk that is guaranteed to contain at least one element. As a result, operations which would not be safe when performed on Chunk, such as head or reduce, are safe when performed on NonEmptyChunk. Operations on NonEmptyChunk which could potentially return an empty chunk will return a Chunk instead.

Self Type
NonEmptyChunk[A]
Linear Supertypes
Serializable, NonEmptySeq[A, NonEmptyChunk, Chunk], NonEmptyOps[A, NonEmptyChunk, Chunk], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. NonEmptyChunk
  2. Serializable
  3. NonEmptySeq
  4. NonEmptyOps
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def ++[A1 >: A](that: Chunk[A1]): NonEmptyChunk[A1]

    Appends the specified Chunk to the end of this NonEmptyChunk.

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

    A symbolic alias for prepended.

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

    A symbolic alias for appended.

  6. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  7. def append[A1 >: A](that: Chunk[A1]): NonEmptyChunk[A1]

    A named alias for ++.

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

    Appends a single element to the end of this NonEmptyChunk.

    Appends a single element to the end of this NonEmptyChunk.

    Definition Classes
    NonEmptyChunk → NonEmptySeq
  9. def asBits(implicit ev: <:<[A, Byte]): NonEmptyChunk[Boolean]

    Converts this NonEmptyChunk of bytes to a NonEmptyChunk of bits.

  10. def asBitsInt(endianness: Endianness)(implicit ev: <:<[A, Int]): NonEmptyChunk[Boolean]

    Converts this NonEmptyChunk of ints to a NonEmptyChunk of bits.

  11. def asBitsLong(endianness: Endianness)(implicit ev: <:<[A, Long]): NonEmptyChunk[Boolean]

    Converts this NonEmptyChunk of longs to a NonEmptyChunk of bits.

  12. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  13. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  14. def collect[B](pf: PartialFunction[A, B]): Chunk[B]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  15. def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
    Definition Classes
    NonEmptyChunk → NonEmptySeq
  16. def distinct: NonEmptyChunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptySeq
  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def equals(that: Any): Boolean

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

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

    Definition Classes
    NonEmptyChunk → AnyRef → Any
  19. def exists(p: (A) => Boolean): Boolean

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

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

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  20. def filter(p: (A) => Boolean): Chunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  21. def filterNot(p: (A) => Boolean): Chunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  22. def find(p: (A) => Boolean): Option[A]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  23. def flatMap[B](f: (A) => NonEmptyChunk[B]): NonEmptyChunk[B]

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

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

    Flattens a NonEmptyChunk of NonEmptyChunk values to a single NonEmptyChunk.

  25. def foldLeft[B](z: B)(op: (B, A) => B): B
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  26. def forall(p: (A) => Boolean): Boolean
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  27. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  28. def groupBy[K](f: (A) => K): Map[K, NonEmptyChunk[A]]

    Groups the values in this NonEmptyChunk using the specified function.

  29. def groupMap[K, V](key: (A) => K)(f: (A) => V): Map[K, NonEmptyChunk[V]]

    Groups and transformers the values in this NonEmptyChunk using the specified function.

  30. def grouped(size: Int): Iterator[NonEmptyChunk[A]]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  31. def hashCode(): Int

    Returns the hashcode of this NonEmptyChunk.

    Returns the hashcode of this NonEmptyChunk.

    Definition Classes
    NonEmptyChunk → AnyRef → Any
  32. def head: A
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  33. def init: Chunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  34. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  35. def iterator: Iterator[A]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  36. def last: A
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  37. def map[B](f: (A) => B): NonEmptyChunk[B]

    Transforms the elements of this NonEmptyChunk with the specified function.

    Transforms the elements of this NonEmptyChunk with the specified function.

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  38. 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.

  39. def mapAccumZIO[R, E, S, B](s: S)(f: (S, A) => ZIO[R, E, (S, B)])(implicit trace: Trace): ZIO[R, E, (S, NonEmptyChunk[B])]

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

  40. def mapZIO[R, E, B](f: (A) => ZIO[R, E, B])(implicit trace: Trace): ZIO[R, E, NonEmptyChunk[B]]

    Effectfully maps the elements of this NonEmptyChunk.

  41. def mapZIOPar[R, E, B](f: (A) => ZIO[R, E, B])(implicit trace: Trace): ZIO[R, E, NonEmptyChunk[B]]

    Effectfully maps the elements of this NonEmptyChunk in parallel.

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

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

  43. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  44. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  45. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  46. def prepend[A1 >: A](that: Chunk[A1]): NonEmptyChunk[A1]

    Prepends the specified Chunk to the beginning of this NonEmptyChunk.

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

    Prepends a single element to the beginning of this NonEmptyChunk.

    Prepends a single element to the beginning of this NonEmptyChunk.

    Definition Classes
    NonEmptyChunk → NonEmptySeq
  48. def reduce[B >: A](op: (B, B) => B): B
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  49. 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.

  50. 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.

  51. def reverse: NonEmptyChunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptySeq
  52. def size: Int
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  53. def sortBy[B](f: (A) => B)(implicit ord: Ordering[B]): NonEmptyChunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptySeq
  54. def sorted[B >: A](implicit ord: Ordering[B]): NonEmptyChunk[B]
    Definition Classes
    NonEmptyChunk → NonEmptySeq
  55. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  56. def tail: Chunk[A]
    Definition Classes
    NonEmptyChunk → NonEmptyOps
  57. def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

    Converts this NonEmptyChunk to an array.

    Converts this NonEmptyChunk to an array.

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  58. def toChunk: Chunk[A]

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

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

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

  60. def toIterable: Iterable[A]

    Converts this NonEmptyChunk to an Iterable.

    Converts this NonEmptyChunk to an Iterable.

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  61. def toList: List[A]

    Converts this NonEmptyChunk to a List.

    Converts this NonEmptyChunk to a List.

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  62. def toString(): String

    Renders this NonEmptyChunk as a String.

    Renders this NonEmptyChunk as a String.

    Definition Classes
    NonEmptyChunk → AnyRef → Any
  63. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  64. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  65. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  66. 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.

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

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  67. 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.

  68. 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.

  69. 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.

  70. def zipWithIndex: NonEmptyChunk[(A, Int)]

    Annotates each element of this NonEmptyChunk with its index.

    Annotates each element of this NonEmptyChunk with its index.

    Definition Classes
    NonEmptyChunk → NonEmptyOps
  71. final def zipWithIndexFrom(indexOffset: Int): NonEmptyChunk[(A, Int)]

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

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from Serializable

Inherited from NonEmptySeq[A, NonEmptyChunk, Chunk]

Inherited from NonEmptyOps[A, NonEmptyChunk, Chunk]

Inherited from AnyRef

Inherited from Any

Ungrouped