object lazySeq extends LazySeq[A] with Closeable
- Alphabetic
- By Inheritance
- lazySeq
- Closeable
- AutoCloseable
- LazySeq
- LazySeqBase
- Traversable
- GenTraversable
- GenericTraversableTemplate
- TraversableLike
- GenTraversableLike
- Parallelizable
- TraversableOnce
- GenTraversableOnce
- FilterMonadic
- HasNewBuilder
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
type
Self = LazySeq[A]
- Attributes
- protected[this]
- Definition Classes
- TraversableLike
-
class
WithFilter extends FilterMonadic[A, Repr]
- Definition Classes
- TraversableLike
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
++[B >: A](rest: LazySeq[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
def
++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike
-
def
++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
addString(b: StringBuilder): StringBuilder
- Definition Classes
- TraversableOnce
-
def
addString(b: StringBuilder, sep: String): StringBuilder
- Definition Classes
- TraversableOnce
-
def
addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
- Definition Classes
- TraversableOnce
-
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
-
final
def
afterWithResource[R, U](resource: Resource[R])(f: (A, R) ⇒ U): LazySeq[A]
Same as after() but takes a Resource (i.e.
Same as after() but takes a Resource (i.e. can use it for something like logging)
- Definition Classes
- LazySeq
-
def
aggregate[B](z: ⇒ B)(seqop: (B, A) ⇒ B, combop: (B, B) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
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
-
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
-
final
def
assertSortedAndUniqueBy[K](key: (A) ⇒ K)(implicit ord: Ordering[K]): LazySeq[A]
- Definition Classes
- LazySeq
-
final
def
assertSortedBy[K](key: (A) ⇒ K)(implicit ord: Ordering[K]): LazySeq[A]
- Definition Classes
- LazySeq
-
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
-
final
def
beforeWithResource[R, U](resource: Resource[R])(f: (A, R) ⇒ U): LazySeq[A]
Same as before() but takes a Resource (i.e.
Same as before() but takes a Resource (i.e. can use it for something like logging)
- Definition Classes
- LazySeq
-
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
-
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
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
close(): Unit
- Definition Classes
- lazySeq → Closeable → AutoCloseable
-
final
def
collapseBy[B >: A, K](key: (B) ⇒ K)(op: (B, B) ⇒ B): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
collect[B](pf: PartialFunction[A, B]): LazySeq[B]
- Definition Classes
- LazySeqBase
-
def
collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
collectFirst[B](pf: PartialFunction[A, B]): Option[B]
- Definition Classes
- TraversableOnce
-
final
def
companion: GenericCompanion[LazySeq]
- Definition Classes
- LazySeqBase → Traversable → GenTraversable → GenericTraversableTemplate
-
def
copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
def
copyToArray[B >: A](xs: Array[B]): Unit
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
copyToArray[B >: A](xs: Array[B], start: Int): Unit
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
copyToBuffer[B >: A](dest: Buffer[B]): Unit
- Definition Classes
- TraversableOnce
-
def
count(p: (A) ⇒ Boolean): Int
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
drop(n: Int): LazySeq[A]
- Definition Classes
- LazySeq → TraversableLike → GenTraversableLike
-
final
def
dropRight(n: Int): LazySeq[A]
- Definition Classes
- LazySeqBase
-
final
def
dropWhile(p: (A) ⇒ Boolean): LazySeq[A]
- Definition Classes
- LazySeq → TraversableLike → GenTraversableLike
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
exists(p: (A) ⇒ Boolean): Boolean
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
final
def
filter(p: (A) ⇒ Boolean): LazySeq[A]
- Definition Classes
- LazySeqBase → TraversableLike → GenTraversableLike
-
final
def
filterNot(p: (A) ⇒ Boolean): LazySeq[A]
- Definition Classes
- LazySeqBase → TraversableLike → GenTraversableLike
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
find(p: (A) ⇒ Boolean): Option[A]
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
final
def
flatMap[B, That](f: (A) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- LazySeqBase → TraversableLike → GenTraversableLike → FilterMonadic
-
final
def
flatten[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): LazySeq[B]
- Definition Classes
- LazySeq → GenericTraversableTemplate
-
def
fold[A1 >: A](z: A1)(op: (A1, A1) ⇒ A1): A1
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
foldLeft[B](z: B)(op: (B, A) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
foldRight[B](z: B)(op: (A, B) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
forall(p: (A) ⇒ Boolean): Boolean
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
def
foreach[U](f: (A) ⇒ U): Unit
This is the method that sub-classes must implement
-
def
genericBuilder[B]: Builder[B, LazySeq[B]]
- Definition Classes
- GenericTraversableTemplate
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
groupBy[B >: A, K](f: (A) ⇒ K)(implicit serializer: Serializer[B]): Map[K, LazySeq[B]]
- Definition Classes
- LazySeq
-
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
-
def
groupBy[K](f: (A) ⇒ K): Map[K, LazySeq[A]]
- Definition Classes
- TraversableLike → GenTraversableLike
-
final
def
grouped[B >: A](size: Int, additionalIncrement: (B) ⇒ Int): LazySeq[IndexedSeq[B]]
- Definition Classes
- LazySeq
-
final
def
grouped[B >: A](size: Int): LazySeq[IndexedSeq[B]]
- Definition Classes
- LazySeq
-
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
-
def
hasDefiniteSize: Boolean
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
- def hasNext: Boolean
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def head: A
- def headOption: Option[A]
-
def
init: LazySeq[A]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
inits: Iterator[LazySeq[A]]
- Definition Classes
- TraversableLike
-
def
isEmpty: Boolean
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
isTraversableAgain: Boolean
- Definition Classes
- TraversableLike → GenTraversableLike → GenTraversableOnce
-
def
last: A
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
lastOption: Option[A]
- Definition Classes
- TraversableLike → GenTraversableLike
-
final
def
map[B, That](f: (A) ⇒ B)(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- LazySeqBase → TraversableLike → GenTraversableLike → FilterMonadic
-
def
max[B >: A](implicit cmp: Ordering[B]): A
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
maxBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
mergeCorresponding[B >: A](that: LazySeq[B])(implicit ord: Ordering[B]): LazySeq[EitherOrBoth[B, B]]
- Definition Classes
- LazySeq
-
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
-
def
min[B >: A](implicit cmp: Ordering[B]): A
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
minBy[B](f: (A) ⇒ B)(implicit cmp: Ordering[B]): A
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
mkString: String
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
mkString(sep: String): String
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
mkString(start: String, sep: String, end: String): String
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
newBuilder(): Builder[A, LazySeq[A]]
- Attributes
- protected[this]
- Definition Classes
- LazySeqBase → GenericTraversableTemplate → TraversableLike → HasNewBuilder
- def next(): A
-
def
nonEmpty: Boolean
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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
-
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
-
def
par: ParIterable[A]
- Definition Classes
- Parallelizable
-
def
parCombiner: Combiner[A, ParIterable[A]]
- Attributes
- protected[this]
- Definition Classes
- TraversableLike → Parallelizable
-
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
-
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
-
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
-
final
def
parForeach[U](f: (A) ⇒ U): Unit
A Parallel foreach
A Parallel foreach
- Definition Classes
- LazySeq
-
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
-
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
-
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
-
def
partition(p: (A) ⇒ Boolean): (LazySeq[A], LazySeq[A])
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
product[B >: A](implicit num: Numeric[B]): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduce[A1 >: A](op: (A1, A1) ⇒ A1): A1
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceLeft[B >: A](op: (B, A) ⇒ B): B
- Definition Classes
- TraversableOnce
-
def
reduceLeftOption[B >: A](op: (B, A) ⇒ B): Option[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceOption[A1 >: A](op: (A1, A1) ⇒ A1): Option[A1]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceRight[B >: A](op: (A, B) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
reduceRightOption[B >: A](op: (A, B) ⇒ B): Option[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
repr: LazySeq[A]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
reversed: List[A]
- Attributes
- protected[this]
- Definition Classes
- TraversableOnce
-
def
scan[B >: A, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
scanLeft[B, That](z: B)(op: (B, A) ⇒ B)(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
scanRight[B, That](z: B)(op: (A, B) ⇒ B)(implicit bf: CanBuildFrom[LazySeq[A], B, That]): That
- Definition Classes
- TraversableLike → GenTraversableLike
- Annotations
- @migration
- Migration
(Changed in version 2.9.0) The behavior of
scanRight
has changed. The previous behavior can be reproduced with scanRight.reverse.
-
final
def
seq: LazySeq[A]
- Definition Classes
- LazySeqBase → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
-
final
def
shuffle[B >: A](implicit serializer: Serializer[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
shuffle[B >: A](seed: Long)(implicit serializer: Serializer[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
shuffle[B >: A](random: Random)(implicit serializer: Serializer[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
def
size: Int
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
sizeHintIfCheap: Int
- Attributes
- protected[collection]
- Definition Classes
- GenTraversableOnce
-
final
def
slice(from: Int, until: Int): LazySeq[A]
- Definition Classes
- LazySeq → TraversableLike → GenTraversableLike
-
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
-
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
-
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
-
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
-
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
-
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
-
final
def
sortBy[B >: A, K](f: (B) ⇒ K)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
sortBy[B >: A, K](serializer: Serializer[B])(f: (B) ⇒ K)(implicit ord: Ordering[K]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
sorted[B >: A](bufferSizeLimitMB: Int, bufferRecordLimit: Int)(implicit serializer: Serializer[B], ord: Ordering[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
sorted[B >: A](implicit serializer: Serializer[B], ord: Ordering[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
def
span(p: (A) ⇒ Boolean): (LazySeq[A], LazySeq[A])
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
splitAt(n: Int): (LazySeq[A], LazySeq[A])
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
stringPrefix: String
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
sum[B >: A](implicit num: Numeric[B]): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
tail: LazySeq[A]
- Definition Classes
- TraversableLike → GenTraversableLike
-
def
tails: Iterator[LazySeq[A]]
- Definition Classes
- TraversableLike
-
final
def
take(n: Int): LazySeq[A]
- Definition Classes
- LazySeq → TraversableLike → GenTraversableLike
-
final
def
takeWhile(p: (A) ⇒ Boolean): LazySeq[A]
- Definition Classes
- LazySeq → TraversableLike → GenTraversableLike
-
def
thisCollection: Traversable[A]
- Attributes
- protected[this]
- Definition Classes
- TraversableLike
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
-
def
toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toBuffer[B >: A]: Buffer[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toCollection(repr: LazySeq[A]): Traversable[A]
- Attributes
- protected[this]
- Definition Classes
- TraversableLike
-
def
toIndexedSeq: IndexedSeq[A]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toIterable: Iterable[A]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toIterator(batchSize: Int = 32, bufferSize: Int = 0): LazySeqIterator[A]
- Definition Classes
- LazySeq
-
def
toIterator: Iterator[A]
- Definition Classes
- TraversableLike → GenTraversableOnce
-
def
toList: List[A]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toSeq: Seq[A]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toSet[B >: A]: Set[B]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
toStream: Stream[A]
- Definition Classes
- TraversableLike → GenTraversableOnce
-
def
toString(): String
- Definition Classes
- TraversableLike → Any
-
def
toTraversable: Traversable[A]
- Definition Classes
- TraversableLike → TraversableOnce → GenTraversableOnce
- Annotations
- @deprecatedOverriding( ... , "2.11.0" )
-
def
toVector: Vector[A]
- Definition Classes
- TraversableOnce → GenTraversableOnce
-
def
transpose[B](implicit asTraversable: (A) ⇒ GenTraversableOnce[B]): LazySeq[LazySeq[B]]
- Definition Classes
- GenericTraversableTemplate
- Annotations
- @migration
- Migration
(Changed in version 2.9.0)
transpose
throws anIllegalArgumentException
if collections are not uniformly sized.
-
final
def
unique: LazySeq[A]
- Definition Classes
- LazySeq
-
final
def
uniqueSortBy[B >: A, K](f: (B) ⇒ K)(implicit serializer: Serializer[B], ord: Ordering[K]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
uniqueSortBy[B >: A, K](serializer: Serializer[B])(f: (B) ⇒ K)(implicit ord: Ordering[K]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
uniqueSorted[B >: A](implicit serializer: Serializer[B], ord: Ordering[B]): LazySeq[B]
- Definition Classes
- LazySeq
-
final
def
uniqueUsing[K](f: (A) ⇒ K): LazySeq[A]
- Definition Classes
- LazySeq
-
def
unzip[A1, A2](implicit asPair: (A) ⇒ (A1, A2)): (LazySeq[A1], LazySeq[A2])
- Definition Classes
- GenericTraversableTemplate
-
def
unzip3[A1, A2, A3](implicit asTriple: (A) ⇒ (A1, A2, A3)): (LazySeq[A1], LazySeq[A2], LazySeq[A3])
- Definition Classes
- GenericTraversableTemplate
-
def
view(from: Int, until: Int): TraversableView[A, LazySeq[A]]
- Definition Classes
- TraversableLike
-
def
view: TraversableView[A, LazySeq[A]]
- Definition Classes
- TraversableLike
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
withFilter(p: (A) ⇒ Boolean): LazySeq[A]
- Definition Classes
- LazySeqBase → TraversableLike → FilterMonadic
-
final
def
zipWithIndex: LazySeq[(A, Int)]
- Definition Classes
- LazySeqBase
- object iterator extends LazySeqIterator[A]
Deprecated Value Members
-
def
/:[B](z: B)(op: (B, A) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.10) Use foldLeft instead of /:
-
def
:\[B](z: B)(op: (A, B) ⇒ B): B
- Definition Classes
- TraversableOnce → GenTraversableOnce
- Annotations
- @deprecated
- Deprecated
(Since version 2.12.10) Use foldRight instead of :\