Packages

sealed trait Chunk[+A] extends AnyRef

A Chunk[A] represents a chunk of values of type A. Chunks are designed are usually backed by arrays, but expose a purely functional, safe interface to the underlying elements, and they become lazy on operations that would be costly with arrays, such as repeated concatenation.

Self Type
Chunk[A]
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Chunk
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def apply(n: Int): A
    Attributes
    protected[zio]
  2. abstract def foreach(f: (A) ⇒ Unit): Unit
    Attributes
    protected[zio]
  3. abstract val length: Int

    The number of elements in the chunk.

  4. abstract def toArray[A1 >: A](n: Int, dest: Array[A1]): Unit
    Attributes
    protected[zio]

Concrete Value Members

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

    Appends an element to the chunk

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

    Returns the concatenation of this chunk with the specified chunk.

  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  8. def collect[B](p: PartialFunction[A, B]): Chunk[B]

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

  9. def collectWhile[B](p: PartialFunction[A, B]): Chunk[B]

    Transforms all elements of the chunk for as long as the specified partial function is defined.

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

    Drops the first n elements of the chunk.

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

    Drops all elements so long as the predicate returns true.

  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(that: Any): Boolean
    Definition Classes
    Chunk → AnyRef → Any
  14. def filter(f: (A) ⇒ Boolean): Chunk[A]

    Returns a filtered subset of this chunk.

  15. final def filterM[R, E](f: (A) ⇒ ZIO[R, E, Boolean]): ZIO[R, E, Chunk[A]]

    Filters this chunk by the specified effectful predicate, retaining all elements for which the predicate evaluates to true.

  16. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  17. def flatMap[B](f: (A) ⇒ Chunk[B]): Chunk[B]

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

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

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

  19. def fold[S](s0: S)(f: (S, A) ⇒ S): S

    Folds over the elements in this chunk from the left.

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

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

    Folds over the elements in this chunk from the right.

  22. final def foldWhile[S](s0: S)(pred: (S) ⇒ Boolean)(f: (S, A) ⇒ S): S

    Folds over the elements in this chunk from the left.

    Folds over the elements in this chunk from the left. Stops the fold early when the condition is not fulfilled.

  23. final def foldWhileM[R, E, S](z: S)(pred: (S) ⇒ Boolean)(f: (S, A) ⇒ ZIO[R, E, S]): ZIO[R, E, S]
  24. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  25. final def hashCode(): Int
    Definition Classes
    Chunk → AnyRef → Any
  26. final def isEmpty: Boolean

    Determines if the chunk is empty.

  27. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  28. def map[B](f: (A) ⇒ B): Chunk[B]

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

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

  30. final def mapAccumM[R, E, S1, B](s1: S1)(f1: (S1, A) ⇒ ZIO[R, E, (S1, B)]): ZIO[R, E, (S1, Chunk[B])]

    Statefully and effectfully maps over the elements of this chunk to produce new elements.

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

    Effectfully maps the elements of this chunk.

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

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

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

    Materializes a chunk into a chunk backed by an array.

    Materializes a chunk into a chunk backed by an array. This method can improve the performance of bulk operations.

  34. final def mkString: String

    Generates a readable string representation of this chunk.

  35. final def mkString(sep: String): String

    Generates a readable string representation of this chunk using the specified separator string.

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

  37. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  38. final def nonEmpty: Boolean

    Determines if the chunk is not empty.

  39. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  40. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  41. final val size: Int

    The number of elements in the chunk.

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

    Returns two splits of this chunk at the specified index.

  43. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  44. final def take(n: Int): Chunk[A]

    Takes the first n elements of the chunk.

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

    Takes all elements so long as the predicate returns true.

  46. def toArray[A1 >: A](implicit tag: ClassTag[A1]): Array[A1]

    Converts the chunk into an array.

  47. def toSeq: Seq[A]
  48. def toString(): String
    Definition Classes
    Chunk → AnyRef → Any
  49. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  50. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  51. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  52. def zipAllWith[B, C](that: Chunk[B])(left: (A) ⇒ C, right: (B) ⇒ C)(both: (A, B) ⇒ C): Chunk[C]
  53. 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.

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

    Zips this chunk with the index of every element.

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

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

Deprecated Value Members

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

    Effectfully traverses the elements of this chunk.

    Effectfully traverses the elements of this chunk.

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use mapM

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

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

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

    Annotations
    @deprecated
    Deprecated

    (Since version 1.0.0) use mapM_

Inherited from AnyRef

Inherited from Any

Ungrouped