basis.collections.immutable

ArraySeq

abstract class ArraySeq[+A] extends Equals with Immutable with Family[ArraySeq[_]] with ArrayLike[A] with IndexedSeq[A]

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

Instance Constructors

  1. new ArraySeq()

Type Members

  1. type Family = ArraySeq[_]

    Definition Classes
    Family

Abstract Value Members

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

    Definition Classes
    IndexedSeq

  2. abstract def erasure: ClassTag[_]

    Definition Classes
    ArrayLike

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 ArraySeq[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 ArraySeq[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  5. 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 ArraySeq[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  6. 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 ArraySeq[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  7. 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 ArraySeq[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  8. def ++:[B >: A](elems: Traverser[B]): ArraySeq[B]

    Returns a copy of this indexed sequence with the given element prepended.

  9. def +:[B >: A](elem: B): ArraySeq[B]

    Returns a copy of this indexed sequence with the given element prepended.

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

    Returns a copy of this indexed sequence with the given element appended.

  11. def :++[B >: A](elems: Traverser[B]): ArraySeq[B]

    Returns a copy of this indexed sequence with the given element appended.

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

    Definition Classes
    AnyRef → Any

  13. def append[B >: A](elem: B): ArraySeq[B]

    Returns a copy of this indexed sequence with the given element appended.

  14. def appendAll[B >: A](elems: Traverser[B]): ArraySeq[B]

    Returns a copy of this indexed sequence with the given elements appended.

  15. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  16. def canEqual(other: Any): Boolean

    Definition Classes
    Seq → Equals

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

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

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

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

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

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

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

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

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

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

  22. def clone(): AnyRef

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

  23. 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 ArraySeq[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  24. 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 ArraySeq[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  25. 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 ArraySeq[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  26. 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 ArraySeq[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  27. 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 ArraySeq[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

  28. def copyToArray[B >: A](index: Int, to: Array[B], offset: Int, count: Int): Unit

    Definition Classes
    ArrayLike

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

    Definition Classes
    AnyRef

  30. def equals(other: Any): Boolean

    Definition Classes
    IndexedSeq → Seq → Equals → Any

  31. def finalize(): Unit

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

  32. 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 ArraySeq[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  33. 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 ArraySeq[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  34. 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 ArraySeq[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  35. 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 ArraySeq[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  36. 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 ArraySeq[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef → Any

  54. def hashCode(): Int

    Definition Classes
    IndexedSeq → Seq → Any

  55. def insert[B >: A](index: Int, elem: B): ArraySeq[B]

    Returns a copy of this indexed sequence with the given element inserted at the given index.

  56. def insertAll[B >: A](index: Int, elems: Traverser[B]): ArraySeq[B]

    Returns a copy of this indexed sequence with the given elements inserted at the given index.

  57. def isEmpty: Boolean

    Definition Classes
    ArraySeq → Container → Collection

  58. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  59. def iterator: Iterator[A]

    Definition Classes
    IndexedSeq → Container

  60. def joinString(separator: String)(implicit builder: StringBuilder): text.StringBuilder.State

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

  61. def joinString(open: String, separator: String, close: String)(implicit builder: StringBuilder): text.StringBuilder.State

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

  62. def length: Int

    Definition Classes
    Seq

  63. 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 ArraySeq[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictTraverserOps

  64. 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 ArraySeq[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  65. 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 ArraySeq[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  66. 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 ArraySeq[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

  67. 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 ArraySeq[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictCollectionOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef

  80. final def notify(): Unit

    Definition Classes
    AnyRef

  81. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  82. def prepend[B >: A](elem: B): ArraySeq[B]

    Returns a copy of this indexed sequence with the given element prepended.

  83. def prependAll[B >: A](elems: Traverser[B]): ArraySeq[B]

    Returns a copy of this indexed sequence with the given elements prepended.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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 ArraySeq[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 ArraySeq[A] to GeneralCollectionOps[A] performed by method CollectionToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralCollectionOps

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

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

  95. def remove(index: Int, count: Int): ArraySeq[A]

    Returns a copy of this indexed sequence with the given index range removed.

  96. def remove(index: Int): ArraySeq[A]

    Returns a copy of this indexed sequence with the given index removed.

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

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

  98. def sortBy[B](f: (A) ⇒ B)(implicit order: Order[B], builder: Builder[A] with From[Seq[_]]): (builder)#State

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

  99. def sorted[B >: A](implicit order: Order[B], builder: Builder[B] with From[Seq[_]]): (builder)#State

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

  100. def stringPrefix: String

    Attributes
    protected
    Definition Classes
    ArraySeq → Collection

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

    Definition Classes
    AnyRef

  102. def toArray[B >: A](implicit B: ClassTag[B]): Array[B]

    Definition Classes
    ArrayLike

  103. def toString(): String

    Definition Classes
    Container → Collection → Any

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

    Definition Classes
    IndexedSeq → Container → Traverser

  105. def update[B >: A](index: Int, elem: B): ArraySeq[B]

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

  106. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  109. 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 ArraySeq[A] to StrictSeqOps[A, Seq[_]] performed by method SeqToStringOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictSeqOps

  110. 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 ArraySeq[A] to StrictIndexedSeqOps[A, IndexedSeq[_]] performed by method IndexedSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictIndexedSeqOps

  111. 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 ArraySeq[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictContainerOps

Shadowed Implicit Value Members

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).+:(elem)(builder)
    Definition Classes
    StrictSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).+:(elem)(builder)
    Definition Classes
    StrictIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).:+(elem)(builder)
    Definition Classes
    StrictSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).:+(elem)(builder)
    Definition Classes
    StrictIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralTraverserOps[A]).count(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralSeqOps[A]).count(p)
    Definition Classes
    GeneralSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralIndexedSeqOps[A]).count(p)
    Definition Classes
    GeneralIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralContainerOps[A]).count(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralCollectionOps[A]).count(p)
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).drop(lower)(builder)
    Definition Classes
    StrictTraverserOps

  11. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).drop(lower)(builder)
    Definition Classes
    StrictSeqOps

  12. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).drop(lower)(builder)
    Definition Classes
    StrictIndexedSeqOps

  13. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).drop(lower)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).drop(lower)(builder)
    Definition Classes
    StrictCollectionOps

  15. 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 ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictTraverserOps

  16. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictSeqOps

  17. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictIndexedSeqOps

  18. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictContainerOps

  19. 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 ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralTraverserOps[A]).eagerly
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralSeqOps[A]).eagerly
    Definition Classes
    GeneralSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralIndexedSeqOps[A]).eagerly
    Definition Classes
    GeneralIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralContainerOps[A]).eagerly
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralCollectionOps[A]).eagerly
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralTraverserOps[A]).exists(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralSeqOps[A]).exists(p)
    Definition Classes
    GeneralSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralIndexedSeqOps[A]).exists(p)
    Definition Classes
    GeneralIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralContainerOps[A]).exists(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralCollectionOps[A]).exists(p)
    Definition Classes
    GeneralCollectionOps

  30. 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 ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).filter(p)(builder)
    Definition Classes
    StrictTraverserOps

  31. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).filter(p)(builder)
    Definition Classes
    StrictSeqOps

  32. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).filter(p)(builder)
    Definition Classes
    StrictIndexedSeqOps

  33. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).filter(p)(builder)
    Definition Classes
    StrictContainerOps

  34. 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 ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).filter(p)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralTraverserOps[A]).find(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralSeqOps[A]).find(p)
    Definition Classes
    GeneralSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralIndexedSeqOps[A]).find(p)
    Definition Classes
    GeneralIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralContainerOps[A]).find(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralCollectionOps[A]).find(p)
    Definition Classes
    GeneralCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralTraverserOps[A]).forall(p)
    Definition Classes
    GeneralTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralSeqOps[A]).forall(p)
    Definition Classes
    GeneralSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralIndexedSeqOps[A]).forall(p)
    Definition Classes
    GeneralIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralContainerOps[A]).forall(p)
    Definition Classes
    GeneralContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralCollectionOps[A]).forall(p)
    Definition Classes
    GeneralCollectionOps

  45. def lazily: NonStrictTraverserOps[A]

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralTraverserOps[A]).lazily
    Definition Classes
    GeneralTraverserOps

  46. macro def lazily: NonStrictSeqOps[A]

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralSeqOps[A]).lazily
    Definition Classes
    GeneralSeqOps

  47. macro def lazily: NonStrictIndexedSeqOps[A]

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralIndexedSeqOps[A]).lazily
    Definition Classes
    GeneralIndexedSeqOps

  48. macro def lazily: NonStrictContainerOps[A]

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralContainerOps[A]).lazily
    Definition Classes
    GeneralContainerOps

  49. def lazily: NonStrictCollectionOps[A]

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: GeneralCollectionOps[A]).lazily
    Definition Classes
    GeneralCollectionOps

  50. 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 ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictTraverserOps

  51. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictSeqOps

  52. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictIndexedSeqOps

  53. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictContainerOps

  54. 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 ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictCollectionOps

  55. 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 ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictTraverserOps

  56. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictSeqOps

  57. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictIndexedSeqOps

  58. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictContainerOps

  59. 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 ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).take(upper)(builder)
    Definition Classes
    StrictTraverserOps

  61. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).take(upper)(builder)
    Definition Classes
    StrictSeqOps

  62. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).take(upper)(builder)
    Definition Classes
    StrictIndexedSeqOps

  63. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).take(upper)(builder)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).take(upper)(builder)
    Definition Classes
    StrictCollectionOps

  65. 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 ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictTraverserOps

  66. 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 ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictSeqOps

  67. 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 ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictIndexedSeqOps

  68. 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 ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictContainerOps

  69. 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 ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictCollectionOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictTraverserOps[A, Traverser[_]]).withFilter(p)
    Definition Classes
    StrictTraverserOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictSeqOps[A, Seq[_]]).withFilter(p)
    Definition Classes
    StrictSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).withFilter(p)
    Definition Classes
    StrictIndexedSeqOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictContainerOps[A, Container[_]]).withFilter(p)
    Definition Classes
    StrictContainerOps

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

    Implicit information
    This member is added by an implicit conversion from ArraySeq[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:
    (arraySeq: StrictCollectionOps[A, Collection[_]]).withFilter(p)
    Definition Classes
    StrictCollectionOps

Inherited from IndexedSeq[A]

Inherited from Seq[A]

Inherited from Container[A]

Inherited from Collection[A]

Inherited from Traverser[A]

Inherited from ArrayLike[A]

Inherited from basis.Family[ArraySeq[_]]

Inherited from Immutable

Inherited from Equals

Inherited from AnyRef

Inherited from Any

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

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

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

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

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

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

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

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

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

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

Indexing

Inserting

Removing

Ungrouped