basis.collections.immutable

IndexTrieSeq

sealed abstract class IndexTrieSeq[+A] extends Equals with Immutable with Family[IndexTrieSeq[_]] with Compound[IndexTrieSeq[A]] with IndexedSeq[A]

Source
IndexTrieSeq.scala
Linear Supertypes
IndexedSeq[A], Seq[A], Container[A], Collection[A], Traverser[A], Compound[IndexTrieSeq[A]], basis.Family[IndexTrieSeq[_]], Immutable, Equals, AnyRef, Any
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. IndexTrieSeq
  2. IndexedSeq
  3. Seq
  4. Container
  5. Collection
  6. Traverser
  7. Compound
  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 IndexTrieSeq()

Type Members

  1. type Family = IndexTrieSeq[_]

    Definition Classes
    Family

Abstract Value Members

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

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

    Definition Classes
    IndexedSeq

  3. abstract def segments: Iterator[IndexTrieSeq[A]]

    Definition Classes
    Compound

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

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

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

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

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

    Definition Classes
    AnyRef → Any

  11. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  12. def canEqual(other: Any): Boolean

    Definition Classes
    Seq → Equals

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

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

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

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

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

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

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

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

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

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

  18. def clone(): AnyRef

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

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

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

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

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

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

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

    Definition Classes
    AnyRef

  25. def equals(other: Any): Boolean

    Definition Classes
    IndexedSeq → Seq → Equals → Any

  26. def finalize(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef → Any

  49. def hashCode(): Int

    Definition Classes
    IndexedSeq → Seq → Any

  50. def isEmpty: Boolean

    Definition Classes
    Container → Collection

  51. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  52. def iterator: Iterator[A]

    Definition Classes
    IndexedSeq → Container

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

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

  54. 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 IndexTrieSeq[A] to GeneralTraverserOps[A] performed by method TraverserToGeneralOps in basis.collections.sequential.General.
    Definition Classes
    GeneralTraverserOps

  55. def length: Int

    Definition Classes
    Seq

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef

  73. final def notify(): Unit

    Definition Classes
    AnyRef

  74. final def notifyAll(): Unit

    Definition Classes
    AnyRef

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  89. def stringPrefix: String

    Attributes
    protected
    Definition Classes
    IndexTrieSeq → Collection

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

    Definition Classes
    AnyRef

  91. def toString(): String

    Definition Classes
    Container → Collection → Any

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

    Definition Classes
    IndexedSeq → Container → Traverser

  93. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

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

  98. 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 IndexTrieSeq[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 IndexTrieSeq[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:
    (indexTrieSeq: 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 IndexTrieSeq[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:
    (indexTrieSeq: StrictIndexedSeqOps[A, IndexedSeq[_]]).:+(elem)(builder)
    Definition Classes
    StrictIndexedSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  43. def lazily: NonStrictTraverserOps[A]

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

  44. macro def lazily: NonStrictSeqOps[A]

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

  45. macro def lazily: NonStrictIndexedSeqOps[A]

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

  46. macro def lazily: NonStrictContainerOps[A]

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

  47. def lazily: NonStrictCollectionOps[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Implicit information
    This member is added by an implicit conversion from IndexTrieSeq[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:
    (indexTrieSeq: 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 Compound[IndexTrieSeq[A]]

Inherited from basis.Family[IndexTrieSeq[_]]

Inherited from Immutable

Inherited from Equals

Inherited from AnyRef

Inherited from Any

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

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

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

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

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

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

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

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

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

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

Ungrouped