basis.collections.immutable

Batch

abstract class Batch[+A] extends Equals with Immutable with Family[Batch[_]] with IndexedSeq[A] with Deque[A]

Source
Batch.scala
Linear Supertypes
Deque[A], Queue[A], Stack[A], BilinearSeq[A], LinearSeq[A], IndexedSeq[A], Seq[A], Container[A], Collection[A], Traverser[A], basis.Family[Batch[_]], Immutable, Equals, AnyRef, Any
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Grouped
  2. Alphabetic
  3. By inheritance
Inherited
  1. Batch
  2. Deque
  3. Queue
  4. Stack
  5. BilinearSeq
  6. LinearSeq
  7. IndexedSeq
  8. Seq
  9. Container
  10. Collection
  11. Traverser
  12. Family
  13. Immutable
  14. Equals
  15. AnyRef
  16. Any
Implicitly
  1. by TraverserToGeneralOps
  2. by SeqToGeneralOps
  3. by LinearSeqToGeneralOps
  4. by IndexedSeqToGeneralOps
  5. by ContainerToGeneralOps
  6. by CollectionToGeneralOps
  7. by BilinearSeqToGeneralOps
  8. by TraverserToStrictOps
  9. by SeqToStringOps
  10. by LinearSeqToStrictOps
  11. by IndexedSeqToStrictOps
  12. by ContainerToStrictOps
  13. by CollectionToStrictOps
  14. by BilinearSeqToStrictOps
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. type Family = Batch[_]

    Definition Classes
    Family

Abstract Value Members

  1. abstract def +:[B >: A](elem: B): Batch[B]

    Definition Classes
    Batch → Deque

  2. abstract def :+[B >: A](elem: B): Batch[B]

    Definition Classes
    Batch → Deque → Queue

  3. abstract def apply(index: Int): A

    Definition Classes
    IndexedSeq

  4. abstract def body: Batch[A]

    Returns all elements except the last of this non-empty deque.

    Returns all elements except the last of this non-empty deque.

    Definition Classes
    Batch → BilinearSeq

  5. abstract def drop(lower: Int): Batch[A]

    Returns all but the first lower elements of this deque.

  6. abstract def foot: A

    Returns the last element of this non-empty bilinear sequence.

    Returns the last element of this non-empty bilinear sequence.

    Definition Classes
    BilinearSeq

  7. abstract def head: A

    Definition Classes
    BilinearSeq → LinearSeq

  8. abstract def tail: Batch[A]

    Definition Classes
    Batch → BilinearSeq → LinearSeq

  9. abstract def take(upper: Int): Batch[A]

    Returns the first upper elements of this deque.

  10. abstract def update[B >: A](index: Int, elem: B): Batch[B]

    Returns a copy of this deque with the given element at the given index.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  2. final def ##(): Int

    Definition Classes
    AnyRef → Any

  3. def ++[B >: A](those: Traverser[B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  4. macro def ++[B >: A](those: Seq[B])(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  5. macro def ++[B >: A](those: LinearSeq[B])(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

  6. macro def ++[B >: A](those: IndexedSeq[B])(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  7. macro def ++[B >: A](those: Container[B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  8. def ++[B >: A](those: Collection[B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  9. macro def ++[B >: A](those: Seq[B])(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  10. def ::[B >: A](elem: B): Batch[B]

    Definition Classes
    Batch → Stack

  11. final def ==(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  12. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  13. def canEqual(other: Any): Boolean

    Definition Classes
    Seq → Equals

  14. def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  15. macro def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  16. macro def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  17. macro def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  18. def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  19. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  20. def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  21. macro def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

  22. macro def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  23. macro def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  24. def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  25. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  26. def equals(other: Any): Boolean

    Definition Classes
    LinearSeq → Seq → Equals → Any

  27. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  28. def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  29. macro def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

  30. macro def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  31. macro def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  32. def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  33. def flatTraverse[B](f: (B) ⇒ Unit)(implicit isNested: <:<[A, Batch[B]]): Unit

    Applies a side-effecting function to each nested element of this deque.

  34. def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  35. macro def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  36. macro def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  37. macro def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  38. macro def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  39. def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  40. macro def fold[B >: A](z: B)(op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  41. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  42. macro def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  43. macro def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  44. macro def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  45. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  46. macro def foldRight[B](z: B)(op: (A, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  47. def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  48. macro def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  49. macro def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  50. macro def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  51. def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  52. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  53. def hashCode(): Int

    Definition Classes
    LinearSeq → Seq → Any

  54. def isEmpty: Boolean

    Definition Classes
    Container → Collection

  55. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  56. def iterator: Iterator[A]

    Definition Classes
    LinearSeq → Container

  57. def length: Int

    Definition Classes
    Seq

  58. def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  59. macro def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

  60. macro def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  61. macro def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  62. def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  63. def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  64. macro def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  65. macro def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  66. macro def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  67. macro def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  68. def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  69. macro def mayReduce[B >: A](op: (B, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  70. def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  71. macro def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  72. macro def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  73. macro def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  74. macro def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  75. def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  76. macro def mayReduceLeft[B >: A](op: (B, A) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  77. macro def mayReduceRight[B >: A](op: (A, B) ⇒ B): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  78. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  79. final def notify(): Unit

    Definition Classes
    AnyRef

  80. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  81. def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  82. macro def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  83. macro def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  84. macro def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  85. macro def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  86. def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  87. macro def reduce[B >: A](op: (B, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  88. def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  89. macro def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  90. macro def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralLinearSeqOps

  91. macro def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  92. macro def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralContainerOps

  93. def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

  94. macro def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralSeqOps

  95. macro def reduceRight[B >: A](op: (A, B) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralIndexedSeqOps

  96. macro def reverse(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  97. def stringPrefix: String

    Attributes
    protected
    Definition Classes
    Batch → Collection

  98. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef

  99. def toString(): String

    Definition Classes
    Container → Collection → Any

  100. def traverse(f: (A) ⇒ Unit): Unit

    Definition Classes
    LinearSeq → Container → Traverser

  101. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  102. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  103. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  104. macro def zip[B](those: LinearSeq[B])(implicit builder: Builder[(A, B)] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

  105. macro def zip[B](those: IndexedSeq[B])(implicit builder: Builder[(A, B)] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  106. macro def zip[B](those: Container[B])(implicit builder: Builder[(A, B)] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

Shadowed Implicit Value Members

  1. macro def +:(elem: A)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).+:(elem)(builder)
    Definition Classes
    StrictSeqOps

  2. macro def +:(elem: A)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).+:(elem)(builder)
    Definition Classes
    StrictLinearSeqOps

  3. macro def +:(elem: A)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).+:(elem)(builder)
    Definition Classes
    StrictIndexedSeqOps

  4. macro def +:(elem: A)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).+:(elem)(builder)
    Definition Classes
    StrictSeqOps

  5. macro def :+(elem: A)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).:+(elem)(builder)
    Definition Classes
    StrictSeqOps

  6. macro def :+(elem: A)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).:+(elem)(builder)
    Definition Classes
    StrictLinearSeqOps

  7. macro def :+(elem: A)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).:+(elem)(builder)
    Definition Classes
    StrictIndexedSeqOps

  8. macro def :+(elem: A)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).:+(elem)(builder)
    Definition Classes
    StrictSeqOps

  9. macro def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).choose(q)
    Definition Classes
    GeneralSeqOps

  10. macro def choose[B](q: PartialFunction[A, B]): Maybe[B]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).choose(q)
    Definition Classes
    GeneralSeqOps

  11. macro def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).collect(q)(builder)
    Definition Classes
    StrictSeqOps

  12. macro def collect[B](q: PartialFunction[A, B])(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).collect(q)(builder)
    Definition Classes
    StrictSeqOps

  13. def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralTraverserOps[A]).count(p)
    Definition Classes
    GeneralTraverserOps

  14. macro def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).count(p)
    Definition Classes
    GeneralSeqOps

  15. macro def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralLinearSeqOps[A]).count(p)
    Definition Classes
    GeneralLinearSeqOps

  16. macro def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralIndexedSeqOps[A]).count(p)
    Definition Classes
    GeneralIndexedSeqOps

  17. macro def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralContainerOps[A]).count(p)
    Definition Classes
    GeneralContainerOps

  18. def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralCollectionOps[A]).count(p)
    Definition Classes
    GeneralCollectionOps

  19. macro def count(p: (A) ⇒ Boolean): Int

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).count(p)
    Definition Classes
    GeneralSeqOps

  20. def drop(lower: Int)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).drop(lower)(builder)
    Definition Classes
    StrictTraverserOps

  21. macro def drop(lower: Int)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).drop(lower)(builder)
    Definition Classes
    StrictSeqOps

  22. macro def drop(lower: Int)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).drop(lower)(builder)
    Definition Classes
    StrictLinearSeqOps

  23. macro def drop(lower: Int)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).drop(lower)(builder)
    Definition Classes
    StrictIndexedSeqOps

  24. macro def drop(lower: Int)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).drop(lower)(builder)
    Definition Classes
    StrictContainerOps

  25. def drop(lower: Int)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).drop(lower)(builder)
    Definition Classes
    StrictCollectionOps

  26. macro def drop(lower: Int)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).drop(lower)(builder)
    Definition Classes
    StrictSeqOps

  27. def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictTraverserOps

  28. macro def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictSeqOps

  29. macro def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictLinearSeqOps

  30. macro def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictIndexedSeqOps

  31. macro def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictContainerOps

  32. def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictCollectionOps

  33. macro def dropWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictSeqOps

  34. def eagerly: StrictTraverserOps[A, Traverser[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralTraverserOps[A]).eagerly
    Definition Classes
    GeneralTraverserOps

  35. macro def eagerly: StrictSeqOps[A, Seq[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).eagerly
    Definition Classes
    GeneralSeqOps

  36. macro def eagerly: StrictLinearSeqOps[A, LinearSeq[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralLinearSeqOps[A]).eagerly
    Definition Classes
    GeneralLinearSeqOps

  37. macro def eagerly: StrictIndexedSeqOps[A, IndexedSeq[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralIndexedSeqOps[A]).eagerly
    Definition Classes
    GeneralIndexedSeqOps

  38. macro def eagerly: StrictContainerOps[A, Container[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralContainerOps[A]).eagerly
    Definition Classes
    GeneralContainerOps

  39. def eagerly: StrictCollectionOps[A, Collection[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralCollectionOps[A]).eagerly
    Definition Classes
    GeneralCollectionOps

  40. macro def eagerly: StrictSeqOps[A, Seq[_]]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).eagerly
    Definition Classes
    GeneralSeqOps

  41. def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralTraverserOps[A]).exists(p)
    Definition Classes
    GeneralTraverserOps

  42. macro def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).exists(p)
    Definition Classes
    GeneralSeqOps

  43. macro def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralLinearSeqOps[A]).exists(p)
    Definition Classes
    GeneralLinearSeqOps

  44. macro def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralIndexedSeqOps[A]).exists(p)
    Definition Classes
    GeneralIndexedSeqOps

  45. macro def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralContainerOps[A]).exists(p)
    Definition Classes
    GeneralContainerOps

  46. def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralCollectionOps[A]).exists(p)
    Definition Classes
    GeneralCollectionOps

  47. macro def exists(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).exists(p)
    Definition Classes
    GeneralSeqOps

  48. def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).filter(p)(builder)
    Definition Classes
    StrictTraverserOps

  49. macro def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).filter(p)(builder)
    Definition Classes
    StrictSeqOps

  50. macro def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).filter(p)(builder)
    Definition Classes
    StrictLinearSeqOps

  51. macro def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).filter(p)(builder)
    Definition Classes
    StrictIndexedSeqOps

  52. macro def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).filter(p)(builder)
    Definition Classes
    StrictContainerOps

  53. def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).filter(p)(builder)
    Definition Classes
    StrictCollectionOps

  54. macro def filter(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).filter(p)(builder)
    Definition Classes
    StrictSeqOps

  55. def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralTraverserOps[A]).find(p)
    Definition Classes
    GeneralTraverserOps

  56. macro def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).find(p)
    Definition Classes
    GeneralSeqOps

  57. macro def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralLinearSeqOps[A]).find(p)
    Definition Classes
    GeneralLinearSeqOps

  58. macro def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralIndexedSeqOps[A]).find(p)
    Definition Classes
    GeneralIndexedSeqOps

  59. macro def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralContainerOps[A]).find(p)
    Definition Classes
    GeneralContainerOps

  60. def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralCollectionOps[A]).find(p)
    Definition Classes
    GeneralCollectionOps

  61. macro def find(p: (A) ⇒ Boolean): Maybe[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).find(p)
    Definition Classes
    GeneralSeqOps

  62. macro def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).flatMap(f)(builder)
    Definition Classes
    StrictSeqOps

  63. macro def flatMap[B](f: (A) ⇒ Traverser[B])(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).flatMap(f)(builder)
    Definition Classes
    StrictSeqOps

  64. macro def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).foldLeft(z)(op)
    Definition Classes
    GeneralSeqOps

  65. macro def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).foldLeft(z)(op)
    Definition Classes
    GeneralSeqOps

  66. def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralTraverserOps[A]).forall(p)
    Definition Classes
    GeneralTraverserOps

  67. macro def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).forall(p)
    Definition Classes
    GeneralSeqOps

  68. macro def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralLinearSeqOps[A]).forall(p)
    Definition Classes
    GeneralLinearSeqOps

  69. macro def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralIndexedSeqOps[A]).forall(p)
    Definition Classes
    GeneralIndexedSeqOps

  70. macro def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralContainerOps[A]).forall(p)
    Definition Classes
    GeneralContainerOps

  71. def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralCollectionOps[A]).forall(p)
    Definition Classes
    GeneralCollectionOps

  72. macro def forall(p: (A) ⇒ Boolean): Boolean

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).forall(p)
    Definition Classes
    GeneralSeqOps

  73. macro def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).foreach(f)
    Definition Classes
    GeneralSeqOps

  74. macro def foreach[U](f: (A) ⇒ U): Unit

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).foreach(f)
    Definition Classes
    GeneralSeqOps

  75. def lazily: NonStrictTraverserOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralTraverserOps[A]).lazily
    Definition Classes
    GeneralTraverserOps

  76. macro def lazily: NonStrictSeqOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method SeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).lazily
    Definition Classes
    GeneralSeqOps

  77. macro def lazily: NonStrictLinearSeqOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralLinearSeqOps[A] performed by method LinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralLinearSeqOps[A]).lazily
    Definition Classes
    GeneralLinearSeqOps

  78. macro def lazily: NonStrictIndexedSeqOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralIndexedSeqOps[A] performed by method IndexedSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralIndexedSeqOps[A]).lazily
    Definition Classes
    GeneralIndexedSeqOps

  79. macro def lazily: NonStrictContainerOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralContainerOps[A] performed by method ContainerToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralContainerOps[A]).lazily
    Definition Classes
    GeneralContainerOps

  80. def lazily: NonStrictCollectionOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralCollectionOps[A]).lazily
    Definition Classes
    GeneralCollectionOps

  81. macro def lazily: NonStrictSeqOps[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to GeneralSeqOps[A] performed by method BilinearSeqToGeneralOps in basis.collections.sequential.General.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: GeneralSeqOps[A]).lazily
    Definition Classes
    GeneralSeqOps

  82. macro def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).map(f)(builder)
    Definition Classes
    StrictSeqOps

  83. macro def map[B](f: (A) ⇒ B)(implicit builder: Builder[B] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).map(f)(builder)
    Definition Classes
    StrictSeqOps

  84. def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictTraverserOps

  85. macro def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictSeqOps

  86. macro def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictLinearSeqOps

  87. macro def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictIndexedSeqOps

  88. macro def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictContainerOps

  89. def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictCollectionOps

  90. macro def slice(lower: Int, upper: Int)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictSeqOps

  91. def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Traverser[_]], builder2: Builder[A] with From[Traverser[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictTraverserOps

  92. macro def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Seq[_]], builder2: Builder[A] with From[Seq[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictSeqOps

  93. macro def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[LinearSeq[_]], builder2: Builder[A] with From[LinearSeq[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictLinearSeqOps

  94. macro def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[IndexedSeq[_]], builder2: Builder[A] with From[IndexedSeq[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictIndexedSeqOps

  95. macro def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Container[_]], builder2: Builder[A] with From[Container[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictContainerOps

  96. def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[Collection[_]], builder2: Builder[A] with From[Collection[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictCollectionOps

  97. macro def span(p: (A) ⇒ Boolean)(implicit builder1: Builder[A] with From[BilinearSeq[_]], builder2: Builder[A] with From[BilinearSeq[_]]): ((builder1)#State, (builder2)#State)

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictSeqOps

  98. def take(upper: Int)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).take(upper)(builder)
    Definition Classes
    StrictTraverserOps

  99. macro def take(upper: Int)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).take(upper)(builder)
    Definition Classes
    StrictSeqOps

  100. macro def take(upper: Int)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).take(upper)(builder)
    Definition Classes
    StrictLinearSeqOps

  101. macro def take(upper: Int)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).take(upper)(builder)
    Definition Classes
    StrictIndexedSeqOps

  102. macro def take(upper: Int)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).take(upper)(builder)
    Definition Classes
    StrictContainerOps

  103. def take(upper: Int)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).take(upper)(builder)
    Definition Classes
    StrictCollectionOps

  104. macro def take(upper: Int)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).take(upper)(builder)
    Definition Classes
    StrictSeqOps

  105. def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Traverser[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictTraverserOps

  106. macro def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictSeqOps

  107. macro def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[LinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictLinearSeqOps

  108. macro def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[IndexedSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictIndexedSeqOps

  109. macro def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Container[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictContainerOps

  110. def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[Collection[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictCollectionOps

  111. macro def takeWhile(p: (A) ⇒ Boolean)(implicit builder: Builder[A] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictSeqOps

  112. def withFilter(p: (A) ⇒ Boolean): Traverser[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictTraverserOps[A, Traverser[_]]).withFilter(p)
    Definition Classes
    StrictTraverserOps

  113. def withFilter(p: (A) ⇒ Boolean): Seq[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).withFilter(p)
    Definition Classes
    StrictSeqOps

  114. def withFilter(p: (A) ⇒ Boolean): LinearSeq[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictLinearSeqOps[A, LinearSeq[_]]).withFilter(p)
    Definition Classes
    StrictLinearSeqOps

  115. def withFilter(p: (A) ⇒ Boolean): IndexedSeq[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictIndexedSeqOps[A, IndexedSeq[_]]).withFilter(p)
    Definition Classes
    StrictIndexedSeqOps

  116. def withFilter(p: (A) ⇒ Boolean): Container[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictContainerOps[A, Container[_]]).withFilter(p)
    Definition Classes
    StrictContainerOps

  117. def withFilter(p: (A) ⇒ Boolean): Collection[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictCollectionOps[A, Collection[_]]).withFilter(p)
    Definition Classes
    StrictCollectionOps

  118. def withFilter(p: (A) ⇒ Boolean): Seq[A]

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).withFilter(p)
    Definition Classes
    StrictSeqOps

  119. macro def zip[B](those: Container[B])(implicit builder: Builder[(A, B)] with From[Seq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, Seq[_]]).zip(those)(builder)
    Definition Classes
    StrictSeqOps

  120. macro def zip[B](those: Container[B])(implicit builder: Builder[(A, B)] with From[BilinearSeq[_]]): (builder)#State

    Implicit information
    This member is added by an implicit conversion from Batch[A] to StrictSeqOps[A, BilinearSeq[_]] performed by method BilinearSeqToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (batch: StrictSeqOps[A, BilinearSeq[_]]).zip(those)(builder)
    Definition Classes
    StrictSeqOps

Inherited from Deque[A]

Inherited from Queue[A]

Inherited from Stack[A]

Inherited from BilinearSeq[A]

Inherited from LinearSeq[A]

Inherited from IndexedSeq[A]

Inherited from Seq[A]

Inherited from Container[A]

Inherited from Collection[A]

Inherited from Traverser[A]

Inherited from basis.Family[Batch[_]]

Inherited from Immutable

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion TraverserToGeneralOps from Batch[A] to GeneralTraverserOps[A]

Inherited by implicit conversion SeqToGeneralOps from Batch[A] to GeneralSeqOps[A]

Inherited by implicit conversion LinearSeqToGeneralOps from Batch[A] to GeneralLinearSeqOps[A]

Inherited by implicit conversion IndexedSeqToGeneralOps from Batch[A] to GeneralIndexedSeqOps[A]

Inherited by implicit conversion ContainerToGeneralOps from Batch[A] to GeneralContainerOps[A]

Inherited by implicit conversion CollectionToGeneralOps from Batch[A] to GeneralCollectionOps[A]

Inherited by implicit conversion BilinearSeqToGeneralOps from Batch[A] to GeneralSeqOps[A]

Inherited by implicit conversion TraverserToStrictOps from Batch[A] to StrictTraverserOps[A, Traverser[_]]

Inherited by implicit conversion SeqToStringOps from Batch[A] to StrictSeqOps[A, Seq[_]]

Inherited by implicit conversion LinearSeqToStrictOps from Batch[A] to StrictLinearSeqOps[A, LinearSeq[_]]

Inherited by implicit conversion IndexedSeqToStrictOps from Batch[A] to StrictIndexedSeqOps[A, IndexedSeq[_]]

Inherited by implicit conversion ContainerToStrictOps from Batch[A] to StrictContainerOps[A, Container[_]]

Inherited by implicit conversion CollectionToStrictOps from Batch[A] to StrictCollectionOps[A, Collection[_]]

Inherited by implicit conversion BilinearSeqToStrictOps from Batch[A] to StrictSeqOps[A, BilinearSeq[_]]

Decomposing

Indexing

Slicing

Traversing

Ungrouped