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]
- Alphabetic
- By Inheritance
- Chunk
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
abstract
def
apply(n: Int): A
- Attributes
- protected[scalaz.zio]
-
abstract
def
foreach(f: (A) ⇒ Unit): Unit
- Attributes
- protected[scalaz.zio]
-
abstract
def
length: Int
The number of elements in the chunk.
-
abstract
def
toArray[A1 >: A](n: Int, dest: Array[A1]): Unit
- Attributes
- protected[scalaz.zio]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
++[A1 >: A](that: Chunk[A1]): Chunk[A1]
Returns the concatenation of this chunk with the specified chunk.
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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
- Definition Classes
- AnyRef
-
def
equals(that: Any): Boolean
- Definition Classes
- Chunk → AnyRef → Any
-
def
filter(f: (A) ⇒ Boolean): Chunk[A]
Returns a filtered subset of this chunk.
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
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
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[E, S](s: S)(f: (S, A) ⇒ IO[E, S]): IO[E, S]
Effectfully folds over the elements in this chunk from the left.
- final def foldMLazy[E, S](z: S)(pred: (S) ⇒ Boolean)(f: (S, A) ⇒ IO[E, S]): IO[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[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
hashCode(): Int
- Definition Classes
- Chunk → AnyRef → Any
-
final
def
isEmpty: Boolean
Determines if the chunk is empty.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
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
. -
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.
-
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
- Definition Classes
- AnyRef
-
final
def
notEmpty: Boolean
Determines if the chunk is not empty.
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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
- Definition Classes
- AnyRef
-
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
- Definition Classes
- Chunk → AnyRef → Any
-
final
def
traverse[E, B](f: (A) ⇒ IO[E, B]): IO[E, Chunk[B]]
Effectfully traverses the elements of this chunk.
-
final
def
traverse_[E](f: (A) ⇒ IO[E, _]): IO[E, Unit]
Effectfully traverses the elements of this chunk purely for the effects.
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
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
zipWithIndex0(indexOffset: Int): Chunk[(A, Int)]
Zips this chunk with the index of every element, starting from the initial index value.