RichTraversableOnce

Instance Constructors

new RichTraversableOnce(self: COL)(implicit toTraversableOnce: (COL) ⇒ TraversableOnce[A])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def collapseBy[K](f: (A) ⇒ K): IndexedSeq[(K, Seq[A])]

Collapse records that are next to each other by a key
Collapse records that are next to each other by a key
e.g.: This groups evens and odds together:
scala> Vector(2,4,6,1,3,2,5,7).collapseBy{ _ % 2 == 0 } res1: IndexedSeq[(Boolean, Seq[Int])] = Vector((true,Vector(2, 4, 6)), (false,Vector(1, 3)), (true,Vector(2)), (false,Vector(5, 7)))
def countBy[K](f: (A) ⇒ K): Map[K, Int]

Like groupBy but returns the count of each key instead of the actual values
def distinctUsing[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): IndexedSeq[A]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def findMapped[B](f: (A) ⇒ Option[B]): Option[B]

A combination of map + find that returns the first Some that is found after applying the map operation.
def findMappedFuture[B](f: (A) ⇒ Future[Option[B]])(implicit ec: ExecutionContext): Future[Option[B]]

Like findMapped except works with Futures.
Like findMapped except works with Futures. Executes the futures one at a time until one with a defined result is found.
def foreachWithIndex[U](f: (A, Int) ⇒ U): Unit
def foreachWithLongIndex[U](f: (A, Long) ⇒ U): Unit
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def maxOption[B >: A](implicit ord: Ordering[B]): Option[A]
def minOption[B >: A](implicit ord: Ordering[B]): Option[A]
def mkStringOrBlank(start: String, sep: String, end: String): String

Same as mkString except if the TraversableOnce is empty then an empty string is returned instead of the start and end params.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
val self: COL
def sortByCached[K](f: (A) ⇒ K)(implicit ord: Ordering[K]): IndexedSeq[A]

Like the normal sortBy but will cache the result of calling f on each element (i.e.
Like the normal sortBy but will cache the result of calling f on each element (i.e. f is only called once for each element). This is useful when f is an expensive function and not just a single field access on the element.
If this is call on something that isn't already an IndexedSeq then it will be automatically converted before sorting.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toHashMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, V]

Like .toMap but creates an immutable.HashMap
def toHashSet: HashSet[A]

Like .toSet but creates an immutable.HashSet
def toMultiValuedLowerAlphaNumericMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, IndexedSeq[V]]
def toMultiValuedMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, Vector[V]]

Like .toHashMap except allows multiple values per key
Like .toHashMap except allows multiple values per key
TODO: Change this to IndexedSeq so we can switch to ImmutableArray (if we want to)
def toMultiValuedMapUsing[K](toKey: (A) ⇒ K): HashMap[K, IndexedSeq[A]]

Like .groupBy but gives you an immutable.HashMap[K, IndexedSeq[A]]
def toMultiValuedMapUsingKeys[K](toKeys: (A) ⇒ TraversableOnce[K]): HashMap[K, IndexedSeq[A]]

Like .groupBy but gives you an immutable.HashMap[K, IndexedSeq[A]]
def toMultiValuedMapWithKeyTransform[K, V, K2](keyTransform: (K) ⇒ K2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, Vector[V]]

Same as toMultiValuedMap but allows you to specify a transform function for the key
Same as toMultiValuedMap but allows you to specify a transform function for the key
TODO: Change this to IndexedSeq so we can switch to ImmutableArray (if we want to)
def toMultiValuedMapWithTransforms[K, V, K2, V2](keyTransform: (K) ⇒ K2, valueTransform: (V) ⇒ V2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, Vector[V2]]

Same as toMultiValuedMap but allows you to specify transform functions for the key and value
Same as toMultiValuedMap but allows you to specify transform functions for the key and value
TODO: Change this to IndexedSeq so we can switch to ImmutableArray (if we want to)
def toMultiValuedURLNameMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, IndexedSeq[V]]
def toSortedSet(implicit ord: Ordering[A]): SortedSet[A]

Like .toSet but returns a scala.collection.immutable.SortedSet instead
def toString(): String

Definition Classes
AnyRef → Any
def toUniqueHashMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, V]

Same as .toHashMap but ensures there are no duplicate keys
def toUniqueHashMapUsing[K](f: (A) ⇒ K): HashMap[K, A]

Alias of uniqueGroupBy
def toUniqueHashMapWithKeyTransform[K, V, K2](keyTransform: (K) ⇒ K2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, V]

Same as toUniqueHashMap but allows you to specify a transform function for the key
def toUniqueHashMapWithTransforms[K, V, K2, V2](keyTransform: (K) ⇒ K2, valueTransform: (V) ⇒ V2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, V2]

Same as toUniqueHashMap but allows you to specify transform functions for the key and value
def toUniqueHashSet: HashSet[A]

Like .toHashSet but makes sure there are no duplicates
def toUniqueLowerAlphaNumericMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, V]
def toUniqueMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, V]

Same as .toMap but ensures there are no duplicate keys
def toUniqueSet: Set[A]

Like .toSet but makes sure there are no duplicates
def toUniqueURLNameMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, V]
def toVector: Vector[A]

Returns a Vector of this Iterable (if it's not already a Vector)
def uniqueGroupBy[K](f: (A) ⇒ K): HashMap[K, A]

Like groupBy but only allows a single value per key
final def wait(arg0: Long, arg1: Int): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Doc: package rich

final class RichTraversableOnce[A, COL] extends AnyRef

Instance Constructors

new RichTraversableOnce(self: COL)(implicit toTraversableOnce: (COL) ⇒ TraversableOnce[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collapseBy[K](f: (A) ⇒ K): IndexedSeq[(K, Seq[A])]

def countBy[K](f: (A) ⇒ K): Map[K, Int]

def distinctUsing[B](f: (A) ⇒ B)(implicit ord: Ordering[B]): IndexedSeq[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def findMapped[B](f: (A) ⇒ Option[B]): Option[B]

def findMappedFuture[B](f: (A) ⇒ Future[Option[B]])(implicit ec: ExecutionContext): Future[Option[B]]

def foreachWithIndex[U](f: (A, Int) ⇒ U): Unit

def foreachWithLongIndex[U](f: (A, Long) ⇒ U): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def maxOption[B >: A](implicit ord: Ordering[B]): Option[A]

def minOption[B >: A](implicit ord: Ordering[B]): Option[A]

def mkStringOrBlank(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val self: COL

def sortByCached[K](f: (A) ⇒ K)(implicit ord: Ordering[K]): IndexedSeq[A]

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

def toHashMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, V]

def toHashSet: HashSet[A]

def toMultiValuedLowerAlphaNumericMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, IndexedSeq[V]]

def toMultiValuedMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, Vector[V]]

def toMultiValuedMapUsing[K](toKey: (A) ⇒ K): HashMap[K, IndexedSeq[A]]

def toMultiValuedMapUsingKeys[K](toKeys: (A) ⇒ TraversableOnce[K]): HashMap[K, IndexedSeq[A]]

def toMultiValuedMapWithKeyTransform[K, V, K2](keyTransform: (K) ⇒ K2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, Vector[V]]

def toMultiValuedMapWithTransforms[K, V, K2, V2](keyTransform: (K) ⇒ K2, valueTransform: (V) ⇒ V2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, Vector[V2]]

def toMultiValuedURLNameMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, IndexedSeq[V]]

def toSortedSet(implicit ord: Ordering[A]): SortedSet[A]

def toString(): String

def toUniqueHashMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, V]

def toUniqueHashMapUsing[K](f: (A) ⇒ K): HashMap[K, A]

def toUniqueHashMapWithKeyTransform[K, V, K2](keyTransform: (K) ⇒ K2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, V]

def toUniqueHashMapWithTransforms[K, V, K2, V2](keyTransform: (K) ⇒ K2, valueTransform: (V) ⇒ V2)(implicit ev: <:<[A, (K, V)]): HashMap[K2, V2]

def toUniqueHashSet: HashSet[A]

def toUniqueLowerAlphaNumericMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, V]

def toUniqueMap[K, V](implicit ev: <:<[A, (K, V)]): HashMap[K, V]

def toUniqueSet: Set[A]

def toUniqueURLNameMap[V](implicit ev: <:<[A, (String, V)]): HashMap[String, V]

def toVector: Vector[A]

def uniqueGroupBy[K](f: (A) ⇒ K): HashMap[K, A]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

Deprecated Value Members

def finalize(): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped