basis.collections

BilinearSeq

trait BilinearSeq[+A] extends Equals with Family[BilinearSeq[_]] with LinearSeq[A]

A bidirectionally decomposable sequence of elements.

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

Type Members

  1. type Family = BilinearSeq[_]

    Definition Classes
    Family

Abstract Value Members

  1. abstract def body: BilinearSeq[A]

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

  2. abstract def foot: A

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

  3. abstract def getClass(): Class[_]

    Definition Classes
    Any

  4. abstract def head: A

    Definition Classes
    BilinearSeq → LinearSeq

  5. abstract def tail: BilinearSeq[A]

    Definition Classes
    BilinearSeq → LinearSeq

Concrete Value Members

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

    Definition Classes
    Any

  2. final def ##(): Int

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

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

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

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

  10. 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 BilinearSeq[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

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

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

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

  13. 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 BilinearSeq[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

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

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

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

    Definition Classes
    Any

  16. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  17. def canEqual(other: Any): Boolean

    Definition Classes
    Seq → Equals

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

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

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

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

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

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

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

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

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

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

  26. def equals(other: Any): Boolean

    Definition Classes
    LinearSeq → Seq → Equals → Any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  45. def hashCode(): Int

    Definition Classes
    LinearSeq → Seq → Any

  46. def isEmpty: Boolean

    Definition Classes
    Container → Collection

  47. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  48. def iterator: Iterator[A]

    Definition Classes
    LinearSeq → Container

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

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

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

  51. def length: Int

    Definition Classes
    Seq

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

  53. 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 BilinearSeq[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  82. def stringPrefix: String

    Attributes
    protected
    Definition Classes
    Collection

  83. def toString(): String

    Definition Classes
    Container → Collection → Any

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

    Definition Classes
    LinearSeq → Container → Traverser

  85. 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 BilinearSeq[A] to StrictLinearSeqOps[A, LinearSeq[_]] performed by method LinearSeqToStrictOps in basis.collections.sequential.Strict.
    Definition Classes
    StrictLinearSeqOps

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

Shadowed Implicit Value Members

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

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

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

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

  3. 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 BilinearSeq[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:
    (bilinearSeq: StrictSeqOps[A, Seq[_]]).collect(q)(builder)
    Definition Classes
    StrictSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  13. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).drop(lower)(builder)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

  19. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).dropWhile(p)(builder)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  37. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).filter(p)(builder)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  47. 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 BilinearSeq[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:
    (bilinearSeq: StrictSeqOps[A, Seq[_]]).flatMap(f)(builder)
    Definition Classes
    StrictSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  59. def lazily: NonStrictTraverserOps[A]

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

  60. macro def lazily: NonStrictSeqOps[A]

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

  61. macro def lazily: NonStrictLinearSeqOps[A]

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

  62. macro def lazily: NonStrictContainerOps[A]

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

  63. def lazily: NonStrictCollectionOps[A]

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

  64. macro def lazily: NonStrictSeqOps[A]

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

  65. 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 BilinearSeq[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:
    (bilinearSeq: StrictSeqOps[A, Seq[_]]).map(f)(builder)
    Definition Classes
    StrictSeqOps

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

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

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

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

  69. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).slice(lower, upper)(builder)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

  73. 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 BilinearSeq[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:
    (bilinearSeq: StrictSeqOps[A, Seq[_]]).sortBy(f)(order, builder)
    Definition Classes
    StrictSeqOps

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

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

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

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

  77. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).span(p)(builder1, builder2)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

  83. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).take(upper)(builder)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

  89. 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 BilinearSeq[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:
    (bilinearSeq: StrictLinearSeqOps[A, LinearSeq[_]]).takeWhile(p)(builder)
    Definition Classes
    StrictLinearSeqOps

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  99. 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 BilinearSeq[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:
    (bilinearSeq: StrictSeqOps[A, Seq[_]]).zip(those)(builder)
    Definition Classes
    StrictSeqOps

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

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

Inherited from LinearSeq[A]

Inherited from Seq[A]

Inherited from Container[A]

Inherited from Collection[A]

Inherited from Traverser[A]

Inherited from basis.Family[BilinearSeq[_]]

Inherited from Equals

Inherited from Any

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

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

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

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

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

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

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

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

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

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

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

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

Decomposing

Ungrouped