GenericParMapTemplate

abstract def companion: GenericCompanion[ParIterable] with GenericParCompanion[ParIterable]

The factory companion object that builds instances of class Traversable.

abstract def head: (K, V)

Selects the first element of this collection.

abstract def isEmpty: Boolean

Tests whether this collection is empty.

abstract def mapCompanion: GenericParMapCompanion[CC]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flatten[B]: Traversable[B]

[use case] Converts this collection of traversable collections into a collection formed by the elements of these traversable collections.

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

abstract def foreach(f: ((K, V)) ⇒ Unit): Unit

[use case]

def genericBuilder[B]: Combiner[B, ParIterable[B]]

The generic builder that builds instances of Traversable at arbitrary element types.

def genericCombiner[B]: Combiner[B, ParIterable[B]]

def genericMapCombiner[P, Q]: Combiner[(P, Q), CC[P, Q]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[(K, V), ParIterable[(K, V)]]

The builder that builds instances of type Traversable[A]

def newCombiner: Combiner[(K, V), CC[K, V]]

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

def transpose[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): ParIterable[ParIterable[B]]

Transposes this collection of traversable collections into a collection of collections.

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

def unzip[A1, A2](implicit asPair: ((K, V)) ⇒ (A1, A2)): (ParIterable[A1], ParIterable[A2])

Converts this collection of pairs into two collections of the first and second half of each pair.

val xs = Traversable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three))

def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) ⇒ (A1, A2, A3)): (ParIterable[A1], ParIterable[A2], ParIterable[A3])

Converts this collection of triples into three collections of the first, second, and third element of each triple.

val xs = Traversable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Traversable(1, 2, 3),
//        Traversable(one, two, three),
//        Traversable(1, 2, 3))

final def wait(): Unit

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

final def wait(arg0: Long): Unit