beam-core
API
Generated with
beam-core/turbolift.data/Chunk

Chunk

turbolift.data.Chunk
See theChunk companion object
sealed abstract class Chunk[+A] extends IterableOnce[A]

Attributes

Companion
object
Graph
Supertypes
trait IterableOnce[A]
class Object
trait Matchable
class Any

Members list

Value members

Abstract methods

def apply(i: Int): A
def depth: Int
def size: Int

Concrete methods

final def ++[A2 >: A](that: Chunk[A2]): Chunk[A2]
final def +:[A2 >: A](value: A2): Chunk[A2]
final def :+[A2 >: A](value: A2): Chunk[A2]
final def auxChangesBy[B](f: A => B, prev: Option[B]): (Chunk[A], Option[B])
final def auxChangesByEff[B, U](f: A => Computation[B, U], prev: Option[B]): Computation[(Chunk[A], Option[B]), U]
final def auxFilterWithPrevious[A2 >: A](f: (A2, A2) => Boolean, prev: Option[A2]): (Chunk[A], Option[A2])
final def auxFilterWithPreviousEff[A2 >: A, U](f: (A, A) => Computation[Boolean, U], prev: Option[A2]): Computation[(Chunk[A], Option[A2]), U]
final def auxIntersperse[B >: A](separator: B, first: Boolean): Chunk[B]
final def auxScanLeft[B](initial: B)(f: (B, A) => B): (Chunk[B], B)
final def auxScanLeftEff[B, U](initial: B)(f: (B, A) => Computation[B, U]): Computation[(Chunk[B], B), U]
final def auxZipWithIndex(initial: Int): Chunk[(A, Int)]
final def auxZipWithLongIndex(initial: Long): Chunk[(A, Long)]
final def build[A2 >: A](cb: ChunkBuilder[A2]): Unit
final def buildSlice[A2 >: A](cb: ChunkBuilder[A2], sliceStart: Int, sliceEnd: Int): Unit
final def changesBy[B](f: A => B): Chunk[A]
final def changesByEff[B, U](f: A => Computation[B, U]): Computation[Chunk[A], U]
final def charsToString(ev: A <:< Char): String
final def collect[B](f: PartialFunction[A, B]): Chunk[B]
final def collectEff[B, U](f: PartialFunction[A, Computation[B, U]]): Computation[Chunk[B], U]
final def collectFirst[B](f: PartialFunction[A, B]): Option[B]
final def collectFirstEff[B, U](f: PartialFunction[A, Computation[B, U]]): Computation[Option[B], U]
final def collectLast[B](f: PartialFunction[A, B]): Option[B]
final def collectLastEff[B, U](f: PartialFunction[A, Computation[B, U]]): Computation[Option[B], U]
final def compact: Chunk[A]
def covary[B](using A <:< B): Chunk[B]
final def decons: Option[(A, Chunk[A])]
final def drop(count: Int): Chunk[A]
final def dropRight(count: Int): Chunk[A]
final def dropRightWhile(f: A => Boolean): Chunk[A]
final def dropRightWhileEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[A], U]
final def dropWhile(f: A => Boolean): Chunk[A]
final def dropWhileEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[A], U]
final def filter(f: A => Boolean): Chunk[A]
final def filterEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[A], U]
final def filterNot(f: A => Boolean): Chunk[A]
final def filterNotEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[A], U]
final def filterWithPrevious[A2 >: A](f: (A2, A2) => Boolean): Chunk[A]
final def filterWithPreviousEff[A2 >: A, U](f: (A, A) => Computation[Boolean, U]): Computation[Chunk[A], U]
final def find(f: A => Boolean): Option[A]
final def findLast(f: A => Boolean): Option[A]
final def flatMap[B](f: A => Chunk[B]): Chunk[B]
final def flatMapEff[B, U](f: A => Computation[Chunk[B], U]): Computation[Chunk[B], U]
final def foldLeft[B](initial: B)(f: (B, A) => B): B
final def foldLeftEff[B, U](initial: B)(f: (B, A) => Computation[B, U]): Computation[B, U]
final def foreach(f: A => Unit): Unit
final def foreachEff[U](f: A => Computation[Unit, U]): Computation[Unit, U]
final def head: A
final def headOption: Option[A]
final def init: Chunk[A]
final def intersperse[B >: A](separator: B): Chunk[B]
final def isEmpty: Boolean
final def last: A
final def lastOption: Option[A]
final def map[B](f: A => B): Chunk[B]
final def mapEff[B, U](f: A => Computation[B, U]): Computation[Chunk[B], U]
final def mapFilter[B](f: A => Option[B]): Chunk[B]
final def mapFilterEff[B, U](f: A => Computation[Option[B], U]): Computation[Chunk[B], U]
final def nonEmpty: Boolean
final def prefixLength(f: A => Boolean): Int
final def prefixLengthEff[U](f: A => Computation[Boolean, U]): Computation[Int, U]
def reverseIterator: Iterator[A]
final def scanLeft[B](initial: B)(f: (B, A) => B): Chunk[B]
final def scanLeftEff[B, U](initial: B)(f: (B, A) => Computation[B, U]): Computation[Chunk[B], U]
final def slice(startIndex: Int, endIndex: Int): Chunk[A]
final def split[A2 >: A](separator: A2): Chunk[Chunk[A]]
final def splitAt(i: Int): (Chunk[A], Chunk[A])
final def splitWhere(f: A => Boolean): Chunk[Chunk[A]]
def splitWhereEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[Chunk[A]], U]
final def suffixLength(f: A => Boolean): Int
final def suffixLengthEff[U](f: A => Computation[Boolean, U]): Computation[Int, U]
final def tail: Chunk[A]
final def take(count: Int): Chunk[A]
final def takeRight(count: Int): Chunk[A]
final def takeRightWhile(f: A => Boolean): Chunk[A]
final def takeRightWhileEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[A], U]
final def takeWhile(f: A => Boolean): Chunk[A]
final def takeWhileEff[U](f: A => Computation[Boolean, U]): Computation[Chunk[A], U]
final def toArray[A2 >: A](using classTag: ClassTag[A2]): Array[A2]
final def toIArray[A2 >: A](using ClassTag[A2]): IArray[A2]
final def toList: List[A]
final def toVector: Vector[A]
final def zipWithIndex(initial: Int): Chunk[(A, Int)]
final def zipWithLongIndex(initial: Long): Chunk[(A, Long)]

Inherited methods

def knownSize: Int

Attributes

Inherited from:
IterableOnce
def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S

Attributes

Inherited from:
IterableOnce

Inherited and Abstract methods

def iterator: Iterator[A]

Attributes

Inherited from:
IterableOnce
Generated with