abstract
class
Batch[+A] extends Equals with Immutable with Family[Batch[_]] with IndexedSeq[A] with Deque[A]
Type Members
-
type
Family = Batch[_]
Abstract Value Members
-
abstract
def
+:[B >: A](elem: B): Batch[B]
-
abstract
def
:+[B >: A](elem: B): Batch[B]
-
abstract
def
apply(index: Int): A
-
abstract
def
body: Batch[A]
-
abstract
def
drop(lower: Int): Batch[A]
-
abstract
def
foot: A
-
abstract
def
head: A
-
abstract
def
tail: Batch[A]
-
abstract
def
take(upper: Int): Batch[A]
-
abstract
def
update[B >: A](index: Int, elem: B): Batch[B]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
++[B >: A](those: Traverser[B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State
-
macro
def
++[B >: A](those: Seq[B])(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State
-
macro
def
++[B >: A](those: LinearSeq[B])(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State
-
macro
def
++[B >: A](those: IndexedSeq[B])(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
++[B >: A](those: Container[B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State
-
def
++[B >: A](those: Collection[B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State
-
macro
def
++[B >: A](those: Seq[B])(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State
-
def
::[B >: A](elem: B): Batch[B]
-
final
def
==(arg0: Any): Boolean
-
final
def
asInstanceOf[T0]: T0
-
def
canEqual(other: Any): Boolean
-
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
macro
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
macro
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
macro
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
def
clone(): AnyRef
-
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State
-
macro
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State
-
macro
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State
-
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(other: Any): Boolean
-
def
finalize(): Unit
-
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State
-
macro
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State
-
macro
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State
-
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State
-
def
flatTraverse[B](f: (B) ⇒ Unit)(implicit isNested: <:<[A, Batch[B]]): Unit
-
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
macro
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
macro
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
macro
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
macro
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
macro
def
fold[B >: A](z: B)(op: (B, B) ⇒ B): B
-
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
macro
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
macro
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
macro
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
macro
def
foldRight[B](z: B)(op: (A, B) ⇒ B): B
-
def
foreach[U](f: (A) ⇒ U): Unit
-
macro
def
foreach[U](f: (A) ⇒ U): Unit
-
macro
def
foreach[U](f: (A) ⇒ U): Unit
-
macro
def
foreach[U](f: (A) ⇒ U): Unit
-
def
foreach[U](f: (A) ⇒ U): Unit
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
def
isEmpty: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
iterator: Iterator[A]
-
def
length: Int
-
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State
-
macro
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State
-
macro
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Container[_]]): (builder)#State
-
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State
-
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
macro
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
macro
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
macro
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
macro
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
macro
def
mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]
-
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
macro
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
macro
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
macro
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
macro
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
macro
def
mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]
-
macro
def
mayReduceRight[B >: A](op: (A, B) ⇒ B): Maybe[B]
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
macro
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
macro
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
macro
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
macro
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
macro
def
reduce[B >: A](op: (B, B) ⇒ B): B
-
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
macro
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
macro
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
macro
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
macro
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
macro
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
-
macro
def
reduceRight[B >: A](op: (A, B) ⇒ B): B
-
macro
def
reverse(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
def
stringPrefix: String
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
def
traverse(f: (A) ⇒ Unit): Unit
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
macro
def
zip[B](those: LinearSeq[B])(implicit builder: Builder[(A, B)] with From[LinearSeq[_]]): (builder)#State
-
macro
def
zip[B](those: IndexedSeq[B])(implicit builder: Builder[(A, B)] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
zip[B](those: Container[B])(implicit builder: Builder[(A, B)] with From[Container[_]]): (builder)#State
Shadowed Implicit Value Members
-
macro
def
+:(elem: A)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
+:(elem: A)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
+:(elem: A)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
+:(elem: A)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
macro
def
:+(elem: A)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
:+(elem: A)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
:+(elem: A)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
:+(elem: A)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
macro
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
macro
def
choose[B](q: PartialFunction[A, B]): Maybe[B]
-
macro
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State
-
macro
def
collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State
-
def
count(p: (A) ⇒ Boolean): Int
-
macro
def
count(p: (A) ⇒ Boolean): Int
-
macro
def
count(p: (A) ⇒ Boolean): Int
-
macro
def
count(p: (A) ⇒ Boolean): Int
-
macro
def
count(p: (A) ⇒ Boolean): Int
-
def
count(p: (A) ⇒ Boolean): Int
-
macro
def
count(p: (A) ⇒ Boolean): Int
-
def
drop(lower: Int)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State
-
macro
def
drop(lower: Int)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
drop(lower: Int)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
drop(lower: Int)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
drop(lower: Int)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State
-
def
drop(lower: Int)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State
-
macro
def
drop(lower: Int)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State
-
macro
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State
-
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State
-
macro
def
dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
-
-
-
-
-
-
-
def
exists(p: (A) ⇒ Boolean): Boolean
-
macro
def
exists(p: (A) ⇒ Boolean): Boolean
-
macro
def
exists(p: (A) ⇒ Boolean): Boolean
-
macro
def
exists(p: (A) ⇒ Boolean): Boolean
-
macro
def
exists(p: (A) ⇒ Boolean): Boolean
-
def
exists(p: (A) ⇒ Boolean): Boolean
-
macro
def
exists(p: (A) ⇒ Boolean): Boolean
-
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State
-
macro
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State
-
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State
-
macro
def
filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
macro
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
macro
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
macro
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
macro
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
macro
def
find(p: (A) ⇒ Boolean): Maybe[A]
-
macro
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State
-
macro
def
flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State
-
macro
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
macro
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
-
def
forall(p: (A) ⇒ Boolean): Boolean
-
macro
def
forall(p: (A) ⇒ Boolean): Boolean
-
macro
def
forall(p: (A) ⇒ Boolean): Boolean
-
macro
def
forall(p: (A) ⇒ Boolean): Boolean
-
macro
def
forall(p: (A) ⇒ Boolean): Boolean
-
def
forall(p: (A) ⇒ Boolean): Boolean
-
macro
def
forall(p: (A) ⇒ Boolean): Boolean
-
macro
def
foreach[U](f: (A) ⇒ U): Unit
-
macro
def
foreach[U](f: (A) ⇒ U): Unit
-
-
-
-
-
-
-
-
macro
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State
-
macro
def
map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State
-
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State
-
macro
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State
-
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State
-
macro
def
slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Traverser[_]], builder2: Builder[A] with From[Traverser[_]]): ((builder1)#State, (builder2)#State)
-
macro
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Seq[_]], builder2: Builder[A] with From[Seq[_]]): ((builder1)#State, (builder2)#State)
-
macro
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[LinearSeq[_]], builder2: Builder[A] with From[LinearSeq[_]]): ((builder1)#State, (builder2)#State)
-
macro
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[IndexedSeq[_]], builder2: Builder[A] with From[IndexedSeq[_]]): ((builder1)#State, (builder2)#State)
-
macro
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Container[_]], builder2: Builder[A] with From[Container[_]]): ((builder1)#State, (builder2)#State)
-
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Collection[_]], builder2: Builder[A] with From[Collection[_]]): ((builder1)#State, (builder2)#State)
-
macro
def
span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[BilinearSeq[_]], builder2: Builder[A] with From[BilinearSeq[_]]): ((builder1)#State, (builder2)#State)
-
def
take(upper: Int)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State
-
macro
def
take(upper: Int)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
take(upper: Int)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
take(upper: Int)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
take(upper: Int)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State
-
def
take(upper: Int)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State
-
macro
def
take(upper: Int)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State
-
macro
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State
-
macro
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State
-
macro
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State
-
macro
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State
-
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State
-
macro
def
takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State
-
def
withFilter(p: (A) ⇒ Boolean): Traverser[A]
-
def
withFilter(p: (A) ⇒ Boolean): Seq[A]
-
def
withFilter(p: (A) ⇒ Boolean): LinearSeq[A]
-
def
withFilter(p: (A) ⇒ Boolean): IndexedSeq[A]
-
def
withFilter(p: (A) ⇒ Boolean): Container[A]
-
def
withFilter(p: (A) ⇒ Boolean): Collection[A]
-
def
withFilter(p: (A) ⇒ Boolean): Seq[A]
-
macro
def
zip[B](those: Container[B])(implicit builder: Builder[(A, B)] with From[Seq[_]]): (builder)#State
-
macro
def
zip[B](those: Container[B])(implicit builder: Builder[(A, B)] with From[BilinearSeq[_]]): (builder)#State
Inherited from Immutable
Inherited from Equals
Inherited from AnyRef
Inherited from Any
Inherited by implicit conversion BilinearSeqToGeneralOps from
Batch[A] to GeneralSeqOps[A]
Decomposing
Indexing
Slicing
Traversing
Ungrouped