fm.lazyseq

DropWhileLazySeq

final class DropWhileLazySeq[A] extends LazySeq[A]

Linear Supertypes
LazySeq[A], FilterMonadic[A, LazySeq[A]], TraversableOnce[A], GenTraversableOnce[A], AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. DropWhileLazySeq
  2. LazySeq
  3. FilterMonadic
  4. TraversableOnce
  5. GenTraversableOnce
  6. AnyRef
  7. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new DropWhileLazySeq(reader: LazySeq[A], p: (A) ⇒ Boolean)

Value Members

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

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def ++[B >: A](rest: LazySeq[B]): LazySeq[B]

    Definition Classes
    LazySeq
  5. def /:[B](z: B)(op: (B, A) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  6. def :\[B](z: B)(op: (A, B) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  7. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  8. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  9. def addString(b: StringBuilder): StringBuilder

    Definition Classes
    TraversableOnce
  10. def addString(b: StringBuilder, sep: String): StringBuilder

    Definition Classes
    TraversableOnce
  11. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Definition Classes
    TraversableOnce
  12. final def after[U](f: (A) ⇒ U): LazySeq[A]

    Run this function on each item after the foreach function

    Run this function on each item after the foreach function

    This is basically a foreach but without forcing evaluation of this LazySeq.

    Definition Classes
    LazySeq
  13. final def afterWithResource[R, U](resource: Resource[R])(f: (A, R) ⇒ U): LazySeq[A]

    Same as after() but takes a Resource (i.

    Same as after() but takes a Resource (i.e. can use it for something like logging)

    Definition Classes
    LazySeq
  14. def aggregate[B](z: B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  15. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  16. final def assertSorted[B >: A](implicit ord: Ordering[B]): LazySeq[B]

    Assert that this reader is in sorted order

    Assert that this reader is in sorted order

    Definition Classes
    LazySeq
  17. final def assertSortedAndUnique[B >: A](implicit ord: Ordering[B]): LazySeq[B]

    Assert that this reader is in sorted order AND unique

    Assert that this reader is in sorted order AND unique

    Definition Classes
    LazySeq
  18. final def assertSortedAndUniqueBy[K](key: (A) ⇒ K)(implicit ord: Ordering[K]): LazySeq[A]

    Definition Classes
    LazySeq
  19. final def assertSortedBy[K](key: (A) ⇒ K)(implicit ord: Ordering[K]): LazySeq[A]

    Definition Classes
    LazySeq
  20. final def before[U](f: (A) ⇒ U): LazySeq[A]

    Run this function on each item before the foreach function

    Run this function on each item before the foreach function

    This is basically a foreach but without forcing evaluation of this LazySeq.

    Definition Classes
    LazySeq
  21. final def beforeWithResource[R, U](resource: Resource[R])(f: (A, R) ⇒ U): LazySeq[A]

    Same as before() but takes a Resource (i.

    Same as before() but takes a Resource (i.e. can use it for something like logging)

    Definition Classes
    LazySeq
  22. final def bucketize[B >: A](num: Int)(implicit serializer: Serializer[B]): Vector[LazySeq[B]]

    Split the LazySeq into num buckets of equal size using a round-robin algorithm

    Split the LazySeq into num buckets of equal size using a round-robin algorithm

    Definition Classes
    LazySeq
  23. final def buffered(size: Int = 0): LazySeq[A]

    Creates an asynchronous buffer that spins up a producer thread which feeds data into a BlockingQueue that is read using the resulting LazySeq.

    Creates an asynchronous buffer that spins up a producer thread which feeds data into a BlockingQueue that is read using the resulting LazySeq.

    Definition Classes
    LazySeq
  24. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  25. final def collapseBy[B >: A, K](key: (B) ⇒ K)(op: (B, B) ⇒ B)(implicit ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  26. def collectFirst[B](pf: PartialFunction[A, B]): Option[B]

    Definition Classes
    TraversableOnce
  27. final def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  28. def copyToArray[B >: A](xs: Array[B]): Unit

    Definition Classes
    TraversableOnce → GenTraversableOnce
  29. def copyToArray[B >: A](xs: Array[B], start: Int): Unit

    Definition Classes
    TraversableOnce → GenTraversableOnce
  30. def copyToBuffer[B >: A](dest: Buffer[B]): Unit

    Definition Classes
    TraversableOnce
  31. def count(p: (A) ⇒ Boolean): Int

    Definition Classes
    TraversableOnce → GenTraversableOnce
  32. final def drop(n: Int): LazySeq[A]

    Definition Classes
    LazySeq
  33. final def dropRight(n: Int): LazySeq[A]

    Definition Classes
    LazySeq
  34. final def dropWhile(p: (A) ⇒ Boolean): LazySeq[A]

    Definition Classes
    LazySeq
  35. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  36. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  37. final def exists(p: (A) ⇒ Boolean): Boolean

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  38. final def filter(p: (A) ⇒ Boolean): LazySeq[A]

    Definition Classes
    LazySeq
  39. final def filterNot(p: (A) ⇒ Boolean): LazySeq[A]

    Definition Classes
    LazySeq
  40. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  41. final def find(p: (A) ⇒ Boolean): Option[A]

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  42. final def flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That

    Definition Classes
    LazySeq → FilterMonadic
  43. final def flatten[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): LazySeq[B]

    Definition Classes
    LazySeq
  44. def fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

    Definition Classes
    TraversableOnce → GenTraversableOnce
  45. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  46. def foldRight[B](z: B)(op: (A, B) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  47. final def forall(p: (A) ⇒ Boolean): Boolean

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  48. final def foreach[U](f: (A) ⇒ U): Unit

    This is the method that sub-classes must implement

    This is the method that sub-classes must implement

    Definition Classes
    DropWhileLazySeqLazySeq → FilterMonadic → TraversableOnce → GenTraversableOnce
  49. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  50. final def groupBy[B >: A, K](f: (A) ⇒ K)(implicit serializer: Serializer[B]): Map[K, LazySeq[B]]

    Definition Classes
    LazySeq
  51. final def groupBy[B >: A, K](serializer: Serializer[B])(f: (A) ⇒ K): Map[K, LazySeq[B]]

    Mostly standard group by implementation that uses tmp files to store the values of the HashMap

    Mostly standard group by implementation that uses tmp files to store the values of the HashMap

    Definition Classes
    LazySeq
  52. final def grouped[B >: A](size: Int): LazySeq[IndexedSeq[B]]

    Definition Classes
    LazySeq
  53. final def groupedBy[K](by: (A) ⇒ K): LazySeq[(K, IndexedSeq[A])]

    A cross between grouped and groupBy that allows you to specify a key to be used (like in groupBy) instead of a fixed count (like in grouped).

    A cross between grouped and groupBy that allows you to specify a key to be used (like in groupBy) instead of a fixed count (like in grouped). All elements next to each other with the same key get returned in each group.

    e.g. LazySeq.wrap(Seq(1,1,1,2,2,1)).groupedBy{ a => a }.toIndexedSeq => Vector((1,Vector(1, 1, 1)), (2,Vector(2, 2)), (1,Vector(1)))

    Definition Classes
    LazySeq
  54. def hasDefiniteSize: Boolean

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  55. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  56. def head: A

    Definition Classes
    LazySeq
  57. def headOption: Option[A]

    Definition Classes
    LazySeq
  58. def isEmpty: Boolean

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  59. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  60. def isTraversableAgain: Boolean

    Definition Classes
    LazySeq → GenTraversableOnce
  61. final def map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That

    Definition Classes
    LazySeq → FilterMonadic
  62. def max[B >: A](implicit cmp: Ordering[B]): A

    Definition Classes
    TraversableOnce → GenTraversableOnce
  63. def maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

    Definition Classes
    TraversableOnce → GenTraversableOnce
  64. final def mergeCorresponding[B >: A](that: LazySeq[B])(implicit ord: Ordering[B]): LazySeq[EitherOrBoth[B, B]]

    Definition Classes
    LazySeq
  65. final def mergeCorrespondingByKey[R, K](that: LazySeq[R], thisKey: (A) ⇒ K, thatKey: (R) ⇒ K)(implicit ord: Ordering[K]): LazySeq[EitherOrBoth[A, R]]

    Merge corresponding records from this sorted read with that sorted reader given a method to get a common key that can be compared.

    Merge corresponding records from this sorted read with that sorted reader given a method to get a common key that can be compared.

    Definition Classes
    LazySeq
  66. def min[B >: A](implicit cmp: Ordering[B]): A

    Definition Classes
    TraversableOnce → GenTraversableOnce
  67. def minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A

    Definition Classes
    TraversableOnce → GenTraversableOnce
  68. def mkString: String

    Definition Classes
    TraversableOnce → GenTraversableOnce
  69. def mkString(sep: String): String

    Definition Classes
    TraversableOnce → GenTraversableOnce
  70. def mkString(start: String, sep: String, end: String): String

    Definition Classes
    TraversableOnce → GenTraversableOnce
  71. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  72. def nonEmpty: Boolean

    Definition Classes
    TraversableOnce → GenTraversableOnce
  73. final def notify(): Unit

    Definition Classes
    AnyRef
  74. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  75. final def onFirst[U](f: (A) ⇒ U): LazySeq[A]

    Execute the method on the first element of the LazySeq whenever it is evaluated.

    Execute the method on the first element of the LazySeq whenever it is evaluated.

    Note: The first element is still call via foreach

    Definition Classes
    LazySeq
  76. final def onLast[U](f: (A) ⇒ U): LazySeq[A]

    Same as onFirst except for the last element whenever it is evaluated

    Same as onFirst except for the last element whenever it is evaluated

    Definition Classes
    LazySeq
  77. final def parFlatMap[B](threads: Int = LazySeq.defaultThreadCount, inputBuffer: Int = LazySeq.defaultThreadCount, resultBuffer: Int = LazySeq.defaultThreadCount * 4)(f: (A) ⇒ GenTraversableOnce[B]): LazySeq[B]

    Performs a parallel flat map maintaining ordered output

    Performs a parallel flat map maintaining ordered output

    Definition Classes
    LazySeq
  78. final def parFlatMap[B](f: (A) ⇒ GenTraversableOnce[B]): LazySeq[B]

    Performs a parallel flat map maintaining ordered output

    Performs a parallel flat map maintaining ordered output

    Definition Classes
    LazySeq
  79. final def parForeach[U](threads: Int = LazySeq.defaultThreadCount, inputBuffer: Int = LazySeq.defaultThreadCount)(f: (A) ⇒ U): Unit

    A Parallel foreach

    A Parallel foreach

    Definition Classes
    LazySeq
  80. final def parForeach[U](f: (A) ⇒ U): Unit

    A Parallel foreach

    A Parallel foreach

    Definition Classes
    LazySeq
  81. final def parMap[B](threads: Int = LazySeq.defaultThreadCount, inputBuffer: Int = LazySeq.defaultThreadCount, resultBuffer: Int = LazySeq.defaultThreadCount * 4)(f: (A) ⇒ B): LazySeq[B]

    Performs a parallel map maintaining ordered output

    Performs a parallel map maintaining ordered output

    Definition Classes
    LazySeq
  82. final def parMap[B](f: (A) ⇒ B): LazySeq[B]

    Performs a parallel map maintaining ordered output

    Performs a parallel map maintaining ordered output

    Definition Classes
    LazySeq
  83. final def partition[B >: A](p: (A) ⇒ Boolean)(implicit serializer: Serializer[B]): (LazySeq[B], LazySeq[B])

    Standard partition implementation using LazySeqs

    Standard partition implementation using LazySeqs

    Definition Classes
    LazySeq
  84. def product[B >: A](implicit num: Numeric[B]): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  85. def reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1

    Definition Classes
    TraversableOnce → GenTraversableOnce
  86. def reduceLeft[B >: A](op: (B, A) ⇒ B): B

    Definition Classes
    TraversableOnce
  87. def reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  88. def reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  89. def reduceRight[B >: A](op: (A, B) ⇒ B): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  90. def reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  91. def reversed: List[A]

    Attributes
    protected[this]
    Definition Classes
    TraversableOnce
  92. def seq: LazySeq[A]

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  93. final def shuffle[B >: A](implicit serializer: Serializer[B]): LazySeq[B]

    Definition Classes
    LazySeq
  94. final def shuffle[B >: A](seed: Long)(implicit serializer: Serializer[B]): LazySeq[B]

    Definition Classes
    LazySeq
  95. final def shuffle[B >: A](random: Random)(implicit serializer: Serializer[B]): LazySeq[B]

    Definition Classes
    LazySeq
  96. def size: Int

    Definition Classes
    TraversableOnce → GenTraversableOnce
  97. final def slice(from: Int, until: Int): LazySeq[A]

    Definition Classes
    LazySeq
  98. final def sortAndCollapseBy[B >: A, K](bufferSizeLimitMB: Int, bufferRecordLimit: Int)(key: (B) ⇒ K)(op: (B, B) ⇒ B)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  99. final def sortAndCollapseBy[B >: A, K](serializer: Serializer[B], bufferSizeLimitMB: Int, bufferRecordLimit: Int)(key: (B) ⇒ K)(op: (B, B) ⇒ B)(implicit ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  100. final def sortAndCollapseBy[B >: A, K](key: (B) ⇒ K)(op: (B, B) ⇒ B)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  101. final def sortAndCollapseBy[B >: A, K](serializer: Serializer[B])(key: (B) ⇒ K)(op: (B, B) ⇒ B)(implicit ord: Ordering[K]): LazySeq[B]

    Collapse elements with the same key by applying a binary operator.

    Collapse elements with the same key by applying a binary operator.

    Should be similar to doing something like: reader.groupBy(key).values.flatMap{ _.reduce(op) }

    Definition Classes
    LazySeq
  102. final def sortBy[B >: A, K](bufferSizeLimitMB: Int, bufferRecordLimit: Int)(f: (B) ⇒ K)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  103. final def sortBy[B >: A, K](serializer: Serializer[B], bufferSizeLimitMB: Int, bufferRecordLimit: Int)(f: (B) ⇒ K)(implicit ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  104. final def sortBy[B >: A, K](f: (B) ⇒ K)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  105. final def sortBy[B >: A, K](serializer: Serializer[B])(f: (B) ⇒ K)(implicit ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  106. final def sorted[B >: A](bufferSizeLimitMB: Int, bufferRecordLimit: Int)(implicit serializer: Serializer[B], ord: Ordering[B]): LazySeq[B]

    Definition Classes
    LazySeq
  107. final def sorted[B >: A](implicit serializer: Serializer[B], ord: Ordering[B]): LazySeq[B]

    Definition Classes
    LazySeq
  108. def sum[B >: A](implicit num: Numeric[B]): B

    Definition Classes
    TraversableOnce → GenTraversableOnce
  109. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  110. final def take(n: Int): LazySeq[A]

    Definition Classes
    LazySeq
  111. final def takeWhile(p: (A) ⇒ Boolean): LazySeq[A]

    Definition Classes
    LazySeq
  112. def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  113. def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  114. def toBuffer[B >: A]: Buffer[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  115. def toIndexedSeq: IndexedSeq[A]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  116. def toIterable: Iterable[A]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  117. def toIterator(batchSize: Int = 32, bufferSize: Int = 0): LazySeqIterator[A]

    Definition Classes
    LazySeq
  118. def toIterator: LazySeqIterator[A]

    Definition Classes
    LazySeq → GenTraversableOnce
  119. def toList: List[A]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  120. def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  121. def toSeq: Seq[A]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  122. def toSet[B >: A]: Set[B]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  123. def toStream: Stream[A]

    Definition Classes
    LazySeq → GenTraversableOnce
  124. def toString(): String

    Definition Classes
    AnyRef → Any
  125. def toTraversable: Traversable[A]

    Definition Classes
    LazySeq → TraversableOnce → GenTraversableOnce
  126. def toVector: Vector[A]

    Definition Classes
    TraversableOnce → GenTraversableOnce
  127. final def unique: LazySeq[A]

    Definition Classes
    LazySeq
  128. final def uniqueSortBy[B >: A, K](f: (B) ⇒ K)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  129. final def uniqueSortBy[B >: A, K](serializer: Serializer[B])(f: (B) ⇒ K)(implicit ord: Ordering[K]): LazySeq[B]

    Definition Classes
    LazySeq
  130. final def uniqueSorted[B >: A](implicit serializer: Serializer[B], ord: Ordering[B]): LazySeq[B]

    Definition Classes
    LazySeq
  131. final def uniqueUsing[K](f: (A) ⇒ K): LazySeq[A]

    Definition Classes
    LazySeq
  132. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  133. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  134. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  135. final def withFilter(p: (A) ⇒ Boolean): LazySeq[A]

    Definition Classes
    LazySeq → FilterMonadic
  136. final def zipWithIndex: LazySeq[(A, Int)]

    Definition Classes
    LazySeq

Deprecated Value Members

  1. def /:\[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1

    Definition Classes
    GenTraversableOnce
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) use fold instead

Inherited from LazySeq[A]

Inherited from FilterMonadic[A, LazySeq[A]]

Inherited from TraversableOnce[A]

Inherited from GenTraversableOnce[A]

Inherited from AnyRef

Inherited from Any

Ungrouped