basis.collections.immutable

::

sealed abstract class ::[A] extends List[A]

Source
List.scala
Linear Supertypes
List[A], Stack[A], LinearSeq[A], Seq[A], Container[A], Collection[A], Traverser[A], ListLike[A], basis.Family[List[_]], Immutable, Equals, AnyRef, Any
Type Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. ::
  2. List
  3. Stack
  4. LinearSeq
  5. Seq
  6. Container
  7. Collection
  8. Traverser
  9. ListLike
  10. Family
  11. Immutable
  12. Equals
  13. AnyRef
  14. Any
Implicitly
  1. by TraverserToGeneralOps
  2. by SeqToGeneralOps
  3. by LinearSeqToGeneralOps
  4. by ContainerToGeneralOps
  5. by CollectionToGeneralOps
  6. by TraverserToStrictOps
  7. by SeqToStringOps
  8. by LinearSeqToStrictOps
  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 ::()

Type Members

  1. type Family = List[_]

    Definition Classes
    Family

Abstract Value Members

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

    Definition Classes
    List → Stack

  2. abstract def head: A

    Definition Classes
    LinearSeq

  3. abstract def reverse: List[A]

    Definition Classes
    List

  4. abstract def tail: List[A]

    Definition Classes
    List → LinearSeq

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

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

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

  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 ::[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 ::[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 ::[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[LinearSeq[_]]): (builder)#State

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

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

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

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

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

    Definition Classes
    AnyRef → Any

  13. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  14. def canEqual(other: Any): Boolean

    Definition Classes
    Seq → Equals

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

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

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

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

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

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

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

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

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

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

  20. def clone(): AnyRef

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

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

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

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

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

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

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

  26. def drop(lower: Int): List[A]

    Definition Classes
    List

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

    Definition Classes
    AnyRef

  28. def equals(other: Any): Boolean

    Definition Classes
    LinearSeq → Seq → Equals → Any

  29. def finalize(): Unit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef → Any

  51. def hashCode(): Int

    Definition Classes
    LinearSeq → Seq → Any

  52. final def isEmpty: Boolean

    Definition Classes
    :: → Container → Collection

  53. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  54. def iterator: Iterator[A]

    Definition Classes
    LinearSeq → Container

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

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

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

  57. def length: Int

    Definition Classes
    List → Seq

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Definition Classes
    AnyRef

  74. final def notify(): Unit

    Definition Classes
    AnyRef

  75. final def notifyAll(): Unit

    Definition Classes
    AnyRef

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  86. def slice(lower: Int, upper: Int): List[A]

    Definition Classes
    List

  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 ::[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 ::[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
    List → Collection

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

    Definition Classes
    AnyRef

  91. def take(upper: Int): List[A]

    Definition Classes
    List

  92. final def toList: List[A]

    Definition Classes
    List → ListLike

  93. def toString(): String

    Definition Classes
    Container → Collection → Any

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

    Definition Classes
    LinearSeq → Container → Traverser

  95. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

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

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

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

Shadowed Implicit Value Members

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  9. 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 ::[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (::: StrictContainerOps[A, Container[_]]).drop(lower)(builder)
    Definition Classes
    StrictContainerOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  41. def lazily: NonStrictTraverserOps[A]

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

  42. macro def lazily: NonStrictSeqOps[A]

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

  43. macro def lazily: NonStrictLinearSeqOps[A]

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

  44. macro def lazily: NonStrictContainerOps[A]

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

  45. def lazily: NonStrictCollectionOps[A]

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

  46. 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 ::[A] to StrictTraverserOps[A, Traverser[_]] performed by method TraverserToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (::: StrictTraverserOps[A, Traverser[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictTraverserOps

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

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

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

  49. 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 ::[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (::: StrictContainerOps[A, Container[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictContainerOps

  50. 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 ::[A] to StrictCollectionOps[A, Collection[_]] performed by method CollectionToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (::: StrictCollectionOps[A, Collection[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictCollectionOps

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

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

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

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

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

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

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

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

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

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

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

  59. 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 ::[A] to StrictContainerOps[A, Container[_]] performed by method ContainerToStrictOps in basis.collections.sequential.Strict.
    Shadowing
    This implicitly inherited member is shadowed by one or more members in this class.
    To access this member you can use a type ascription:
    (::: StrictContainerOps[A, Container[_]]).take(upper)(builder)
    Definition Classes
    StrictContainerOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inherited from List[A]

Inherited from Stack[A]

Inherited from LinearSeq[A]

Inherited from Seq[A]

Inherited from Container[A]

Inherited from Collection[A]

Inherited from Traverser[A]

Inherited from ListLike[A]

Inherited from basis.Family[List[_]]

Inherited from Immutable

Inherited from Equals

Inherited from AnyRef

Inherited from Any

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

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

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

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

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

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

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

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

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

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

Ungrouped