Trait/Object

basis.collections

LinearSeq

Related Docs: object LinearSeq | package collections

Permalink

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

A recursively decomposable sequence of elements.

Source
LinearSeq.scala
Linear Supertypes
Seq[A], Container[A], Collection[A], Traverser[A], basis.Family[LinearSeq[_]], Equals, Any
Known Subclasses
::, BilinearSeq, Deque, Empty, FingerTrieSeq, List, Nil, Path, Query, Queue, Segment, Slash, Slash, SlashOrEmpty, Stack
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. LinearSeq
  2. Seq
  3. Container
  4. Collection
  5. Traverser
  6. Family
  7. Equals
  8. Any
Implicitly
  1. by TraverserToStrictOps
  2. by SeqToStringOps
  3. by ContainerToStrictOps
  4. by CollectionToStrictOps
  5. by LinearSeqToStrictOps
  6. by TraverserToGeneralOps
  7. by SeqToGeneralOps
  8. by ContainerToGeneralOps
  9. by CollectionToGeneralOps
  10. by LinearSeqToGeneralOps
  1. Hide All
  2. Show all
Visibility
  1. Public
  2. All

Type Members

  1. type Family = LinearSeq[_]

    Permalink
    Definition Classes
    Family

Abstract Value Members

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

    Permalink
    Definition Classes
    Any

  2. abstract def head: A

    Permalink

  3. abstract def tail: LinearSeq[A]

    Permalink

Concrete Value Members

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

    Permalink
    Definition Classes
    Any

  2. final def ##(): Int

    Permalink
    Definition Classes
    Any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Permalink
    Definition Classes
    Any

  13. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any

  14. def canEqual(other: Any): Boolean

    Permalink
    Definition Classes
    Seq → Equals

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  25. def equals(other: Any): Boolean

    Permalink
    Definition Classes
    LinearSeq → Seq → Equals → Any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  46. def hashCode(): Int

    Permalink
    Definition Classes
    LinearSeq → Seq → Any

  47. def isEmpty: Boolean

    Permalink
    Definition Classes
    Container → Collection

  48. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any

  49. def iterator: Iterator[A]

    Permalink
    Definition Classes
    LinearSeq → Container

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

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

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

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

  52. def length: Int

    Permalink
    Definition Classes
    Seq

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  80. def stringPrefix: String

    Permalink
    Attributes
    protected
    Definition Classes
    Collection

  81. def toString(): String

    Permalink
    Definition Classes
    Container → Collection → Any

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

    Permalink
    Definition Classes
    LinearSeq → Container → Traverser

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

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

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

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

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

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

Shadowed Implicit Value Members

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  41. def lazily: NonStrictTraverserOps[A]

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

  42. macro def lazily: NonStrictSeqOps[A]

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

  43. macro def lazily: NonStrictContainerOps[A]

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

  44. def lazily: NonStrictCollectionOps[A]

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

  45. macro def lazily: NonStrictLinearSeqOps[A]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Inherited from Seq[A]

Inherited from Container[A]

Inherited from Collection[A]

Inherited from Traverser[A]

Inherited from basis.Family[LinearSeq[_]]

Inherited from Equals

Inherited from Any

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

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

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

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

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

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

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

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

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

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

Ungrouped