Packages

trait ParMap[K, +V] extends GenericParMapTemplate[K, V, ParMap] with parallel.ParMap[K, V] with ParIterable[(K, V)] with ParMapLike[K, V, ParMap, ParMap[K, V], immutable.Map[K, V]]

A template trait for immutable parallel maps.

The higher-order functions passed to certain operations may contain side-effects. Since implementations of bulk operations may not be sequential, this means that side-effects may not be predictable and may produce data-races, deadlocks or invalidation of state if care is not taken. It is up to the programmer to either avoid using side-effects or to use some form of synchronization when accessing mutable data.

K

the key type of the map

V

the value type of the map

Self Type
ParMap[K, V]
Linear Supertypes
ParMapLike[K, V, ParMap, ParMap[K, V], immutable.Map[K, V]], ParIterable[(K, V)], parallel.ParMap[K, V], parallel.ParMapLike[K, V, [X, Y]ParMap[X, Y], ParMap[K, V], immutable.Map[K, V]], Equals, parallel.ParIterable[(K, V)], ParIterableLike[(K, V), [X]ParIterable[X], ParMap[K, V], immutable.Map[K, V]], Parallel, CustomParallelizable[(K, V) @scala.annotation.unchecked.uncheckedVariance, ParMap[K, V]], Parallelizable[(K, V) @scala.annotation.unchecked.uncheckedVariance, ParMap[K, V]], IterableOnce[(K, V) @scala.annotation.unchecked.uncheckedVariance], GenericParMapTemplate[K, V, [X, Y]ParMap[X, Y]], GenericParTemplate[(K, V), [X]ParIterable[X]], HasNewCombiner[(K, V) @scala.annotation.unchecked.uncheckedVariance, ParMap[K, V]], GenericTraversableTemplate[(K, V), [X]ParIterable[X]], HasNewBuilder[(K, V), scala.collection.parallel.immutable.ParIterable[(K, V)] @scala.annotation.unchecked.uncheckedVariance], AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ParMap
  2. ParMapLike
  3. ParIterable
  4. ParMap
  5. ParMapLike
  6. Equals
  7. ParIterable
  8. ParIterableLike
  9. Parallel
  10. CustomParallelizable
  11. Parallelizable
  12. IterableOnce
  13. GenericParMapTemplate
  14. GenericParTemplate
  15. HasNewCombiner
  16. GenericTraversableTemplate
  17. HasNewBuilder
  18. AnyRef
  19. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. trait BuilderOps[Elem, To] extends AnyRef
    Definition Classes
    ParIterableLike
  2. trait SignallingOps[PI <: DelegatedSignalling] extends AnyRef
    Definition Classes
    ParIterableLike
  3. trait TaskOps[R, Tp] extends AnyRef
    Definition Classes
    ParIterableLike
  4. type SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]
    Definition Classes
    ParIterableLike

Abstract Value Members

  1. abstract def +[U >: V](kv: (K, U)): ParMap[K, U]
    Definition Classes
    ParMapLikeParMapLike
  2. abstract def -(key: K): ParMap[K, V]
    Definition Classes
    ParMapLikeParMapLike
  3. abstract def get(key: K): Option[V]
    Definition Classes
    ParMapLike
  4. abstract def seq: immutable.Map[K, V]
    Definition Classes
    ParIterableLikeParallelizable
  5. abstract def size: Int
    Definition Classes
    ParIterableLike

Concrete Value Members

  1. final def ++[V2 >: V](xs: IterableOnce[(K, V2)]): ParMap[K, V2]

    Alias for concat

    Alias for concat

    Definition Classes
    ParMapLike
    Annotations
    @inline()
  2. def ++[U >: (K, V)](that: scala.IterableOnce[U]): ParIterable[U]
    Definition Classes
    ParIterableLike
  3. def /:[S](z: S)(op: (S, (K, V)) => S): S
    Definition Classes
    ParIterableLike
  4. def :\[S](z: S)(op: ((K, V), S) => S): S
    Definition Classes
    ParIterableLike
  5. def aggregate[S](z: => S)(seqop: (S, (K, V)) => S, combop: (S, S) => S): S

    Aggregates the results of applying an operator to subsequent elements.

    Aggregates the results of applying an operator to subsequent elements.

    This is a more general form of fold and reduce. It has similar semantics, but does not require the result to be a supertype of the element type. It traverses the elements in different partitions sequentially, using seqop to update the result, and then applies combop to results from different partitions. The implementation of this operation may operate on an arbitrary number of collection partitions, so combop may be invoked arbitrary number of times.

    For example, one might want to process some elements and then produce a Set. In this case, seqop would process an element and append it to the set, while combop would concatenate two sets from different partitions together. The initial value z would be an empty set.

    pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)

    Another example is calculating geometric mean from a collection of doubles (one would typically require big doubles for this).

    S

    the type of accumulated results

    z

    the initial value for the accumulated result of the partition - this will typically be the neutral element for the seqop operator (e.g. Nil for list concatenation or 0 for summation) and may be evaluated more than once

    seqop

    an operator used to accumulate results within a partition

    combop

    an associative operator used to combine results from different partitions

    Definition Classes
    ParIterableLike
  6. def apply(key: K): V
    Definition Classes
    ParMapLike
  7. def canEqual(that: Any): Boolean
    Definition Classes
    ParMapLike → Equals
  8. def collect[K2, V2](pf: PartialFunction[(K, V), (K2, V2)]): ParMap[K2, V2]

    Builds a new collection by applying a partial function to all elements of this parallel map on which the function is defined.

    Builds a new collection by applying a partial function to all elements of this parallel map on which the function is defined.

    K2

    the key type of the returned parallel map.

    V2

    the value type of the returned parallel map.

    pf

    the partial function which filters and maps the parallel map.

    returns

    a new parallel map resulting from applying the given partial function pf to each element on which it is defined and collecting the results. The order of the elements is preserved.

    Definition Classes
    ParMapLike
  9. def collect[S](pf: PartialFunction[(K, V), S]): ParIterable[S]
    Definition Classes
    ParIterableLike
  10. def companion: GenericParCompanion[ParIterable]

    The factory companion object that builds instances of class ParMap.

    The factory companion object that builds instances of class ParMap. (or its Iterable superclass where class ParMap is not a Seq.)

    Definition Classes
    ParIterableParIterableParIterableLikeGenericParTemplateGenericTraversableTemplate
  11. def concat[V2 >: V](that: IterableOnce[(K, V2)]): ParMap[K, V2]

    Returns a new parallel map containing the elements from the left hand operand followed by the elements from the right hand operand.

    Returns a new parallel map containing the elements from the left hand operand followed by the elements from the right hand operand. The element type of the parallel map is the most specific superclass encompassing the element types of the two operands.

    that

    the collection or iterator to append.

    returns

    a new parallel map which contains all elements of this parallel map followed by all elements of suffix.

    Definition Classes
    ParMapLike
  12. def contains(key: K): Boolean
    Definition Classes
    ParMapLike
  13. def copyToArray[U >: (K, V)](xs: Array[U], start: Int, len: Int): Unit
    Definition Classes
    ParIterableLike
  14. def copyToArray[U >: (K, V)](xs: Array[U], start: Int): Unit
    Definition Classes
    ParIterableLike
  15. def copyToArray[U >: (K, V)](xs: Array[U]): Unit
    Definition Classes
    ParIterableLike
  16. def count(p: ((K, V)) => Boolean): Int
    Definition Classes
    ParIterableLike
  17. def debugBuffer: ArrayBuffer[String]
    Definition Classes
    ParIterableLike
  18. def default(key: K): V
    Definition Classes
    ParMapLike
  19. def drop(n: Int): ParMap[K, V]
    Definition Classes
    ParIterableLike
  20. def dropWhile(pred: ((K, V)) => Boolean): ParMap[K, V]

    Drops all elements in the longest prefix of elements that satisfy the predicate, and returns a collection composed of the remaining elements.

    Drops all elements in the longest prefix of elements that satisfy the predicate, and returns a collection composed of the remaining elements.

    This method will use indexFlag signalling capabilities. This means that splitters may set and read the indexFlag state. The index flag is initially set to maximum integer value.

    pred

    the predicate used to test the elements

    returns

    a collection composed of all the elements after the longest prefix of elements in this parallel map that satisfy the predicate pred

    Definition Classes
    ParIterableLike
  21. def empty: ParMap[K, V]
    Definition Classes
    ParMapParMapLikeParMapParMapLike
  22. def equals(that: Any): Boolean

    Compares two maps structurally; i.e., checks if all mappings contained in this map are also contained in the other map, and vice versa.

    Compares two maps structurally; i.e., checks if all mappings contained in this map are also contained in the other map, and vice versa.

    that

    the other map

    returns

    true if both maps contain exactly the same mappings, false otherwise.

    Definition Classes
    ParMapLike → Equals → AnyRef → Any
  23. def exists(p: ((K, V)) => Boolean): Boolean

    Tests whether a predicate holds for some element of this parallel map.

    Tests whether a predicate holds for some element of this parallel map.

    This method will use abort signalling capabilities. This means that splitters may send and read abort signals.

    p

    a predicate used to test elements

    returns

    true if p holds for some element, false otherwise

    Definition Classes
    ParIterableLike
  24. def filter(pred: ((K, V)) => Boolean): ParMap[K, V]
    Definition Classes
    ParIterableLike
  25. def filterKeys(p: (K) => Boolean): parallel.ParMap[K, V]
    Definition Classes
    ParMapLike
  26. def filterNot(pred: ((K, V)) => Boolean): ParMap[K, V]
    Definition Classes
    ParIterableLike
  27. def find(p: ((K, V)) => Boolean): Option[(K, V)]

    Finds some element in the collection for which the predicate holds, if such an element exists.

    Finds some element in the collection for which the predicate holds, if such an element exists. The element may not necessarily be the first such element in the iteration order.

    If there are multiple elements obeying the predicate, the choice is nondeterministic.

    This method will use abort signalling capabilities. This means that splitters may send and read abort signals.

    p

    predicate used to test the elements

    returns

    an option value with the element if such an element exists, or None otherwise

    Definition Classes
    ParIterableLike
  28. def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)]): ParMap[K2, V2]

    Builds a new map by applying a function to all elements of this parallel map and using the elements of the resulting collections.

    Builds a new map by applying a function to all elements of this parallel map and using the elements of the resulting collections.

    f

    the function to apply to each element.

    returns

    a new parallel map resulting from applying the given collection-valued function f to each element of this parallel map and concatenating the results.

    Definition Classes
    ParMapLike
  29. def flatMap[S](f: ((K, V)) => scala.IterableOnce[S]): ParIterable[S]
    Definition Classes
    ParIterableLike
  30. def flatten[B]: <error>

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

    [use case]

    Converts this parallel map of traversable collections into a parallel map formed by the elements of these traversable collections.

    The resulting collection's type will be guided by the static type of parallel map. For example:

    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)
    B

    the type of the elements of each traversable collection.

    returns

    a new parallel map resulting from concatenating all element parallel maps.

    Definition Classes
    GenericTraversableTemplate
    Full Signature

    def flatten[B](implicit asTraversable: ((K, V)) => scala.IterableOnce[B]): ParIterable[B]

  31. def fold[U >: (K, V)](z: U)(op: (U, U) => U): U

    Folds the elements of this sequence using the specified associative binary operator.

    Folds the elements of this sequence using the specified associative binary operator. The order in which the elements are reduced is unspecified and may be nondeterministic.

    Note this method has a different signature than the foldLeft and foldRight methods of the trait Traversable. The result of folding may only be a supertype of this parallel collection's type parameter T.

    U

    a type parameter for the binary operator, a supertype of T.

    z

    a neutral element for the fold operation, it may be added to the result an arbitrary number of times, not changing the result (e.g. Nil for list concatenation, 0 for addition, or 1 for multiplication)

    op

    a binary operator that must be associative

    returns

    the result of applying fold operator op between all the elements and z

    Definition Classes
    ParIterableLike
  32. def foldLeft[S](z: S)(op: (S, (K, V)) => S): S
    Definition Classes
    ParIterableLike
  33. def foldRight[S](z: S)(op: ((K, V), S) => S): S
    Definition Classes
    ParIterableLike
  34. def forall(p: ((K, V)) => Boolean): Boolean

    Tests whether a predicate holds for all elements of this parallel map.

    Tests whether a predicate holds for all elements of this parallel map.

    This method will use abort signalling capabilities. This means that splitters may send and read abort signals.

    p

    a predicate used to test elements

    returns

    true if p holds for all elements, false otherwise

    Definition Classes
    ParIterableLike
  35. def foreach[U](f: ((K, V)) => U): Unit

    Applies a function f to all the elements of parallel map in an undefined order.

    Applies a function f to all the elements of parallel map in an undefined order.

    U

    the result type of the function applied to each element, which is always discarded

    f

    function applied to each element

    Definition Classes
    ParIterableLike
  36. def genericBuilder[B]: Combiner[B, ParIterable[B]]

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

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

    Definition Classes
    GenericParTemplateGenericTraversableTemplate
  37. def genericCombiner[B]: Combiner[B, ParIterable[B]]
    Definition Classes
    GenericParTemplate
  38. def genericMapCombiner[P, Q]: Combiner[(P, Q), ParMap[P, Q]]
    Definition Classes
    GenericParMapTemplate
  39. def getOrElse[U >: V](key: K, default: => U): U
    Definition Classes
    ParMapLike
  40. def groupBy[K](f: ((K, V)) => K): ParMap[K, ParMap[K, V]]
    Definition Classes
    ParIterableLike
  41. def hasDefiniteSize: Boolean
    Definition Classes
    ParIterableLike
  42. def hashCode(): Int
    Definition Classes
    ParMapLike → AnyRef → Any
  43. def head: (K, V)
    Definition Classes
    ParIterableLike
  44. def headOption: Option[(K, V)]
    Definition Classes
    ParIterableLike
  45. def init: ParMap[K, V]
    Definition Classes
    ParIterableLike
  46. def isDefinedAt(key: K): Boolean
    Definition Classes
    ParMapLike
  47. def isEmpty: Boolean
    Definition Classes
    ParIterableLike
  48. def isStrictSplitterCollection: Boolean

    Denotes whether this parallel collection has strict splitters.

    Denotes whether this parallel collection has strict splitters.

    This is true in general, and specific collection instances may choose to override this method. Such collections will fail to execute methods which rely on splitters being strict, i.e. returning a correct value in the remaining method.

    This method helps ensure that such failures occur on method invocations, rather than later on and in unpredictable ways.

    Definition Classes
    ParIterableLike
  49. final def isTraversableAgain: Boolean
    Definition Classes
    ParIterableLike
  50. def iterator: Splitter[(K, V)]

    Creates a new split iterator used to traverse the elements of this collection.

    Creates a new split iterator used to traverse the elements of this collection.

    By default, this method is implemented in terms of the protected splitter method.

    returns

    a split iterator

    Definition Classes
    ParIterableLike → IterableOnce
  51. def keySet: parallel.ParSet[K]
    Definition Classes
    ParMapLike
  52. def keys: parallel.ParIterable[K]
    Definition Classes
    ParMapLike
  53. def keysIterator: IterableSplitter[K]
    Definition Classes
    ParMapLike
  54. def knownSize: Int
    Definition Classes
    IterableOnce
  55. def last: (K, V)
    Definition Classes
    ParIterableLike
  56. def lastOption: Option[(K, V)]
    Definition Classes
    ParIterableLike
  57. def map[K2, V2](f: ((K, V)) => (K2, V2)): ParMap[K2, V2]

    Builds a new map by applying a function to all elements of this parallel map.

    Builds a new map by applying a function to all elements of this parallel map.

    f

    the function to apply to each element.

    returns

    a new parallel map resulting from applying the given function f to each element of this parallel map and collecting the results.

    Definition Classes
    ParMapLike
  58. def map[S](f: ((K, V)) => S): ParIterable[S]
    Definition Classes
    ParIterableLike
  59. def mapCompanion: GenericParMapCompanion[ParMap]
    Definition Classes
    ParMapParMapLikeParMapParMapLikeGenericParMapTemplate
  60. def mapValues[S](f: (V) => S): parallel.ParMap[K, S]
    Definition Classes
    ParMapLike
  61. def max[U >: (K, V)](implicit ord: Ordering[U]): (K, V)
    Definition Classes
    ParIterableLike
  62. def maxBy[S](f: ((K, V)) => S)(implicit cmp: Ordering[S]): (K, V)
    Definition Classes
    ParIterableLike
  63. def min[U >: (K, V)](implicit ord: Ordering[U]): (K, V)
    Definition Classes
    ParIterableLike
  64. def minBy[S](f: ((K, V)) => S)(implicit cmp: Ordering[S]): (K, V)
    Definition Classes
    ParIterableLike
  65. def mkString: String
    Definition Classes
    ParIterableLike
  66. def mkString(sep: String): String
    Definition Classes
    ParIterableLike
  67. def mkString(start: String, sep: String, end: String): String
    Definition Classes
    ParIterableLike
  68. def nonEmpty: Boolean
    Definition Classes
    ParIterableLike
  69. def par: ParMap[K, V]

    Returns a parallel implementation of this collection.

    Returns a parallel implementation of this collection.

    For most collection types, this method creates a new parallel collection by copying all the elements. For these collection, par takes linear time. Mutable collections in this category do not produce a mutable parallel collection that has the same underlying dataset, so changes in one collection will not be reflected in the other one.

    Specific collections (e.g. ParArray or mutable.ParHashMap) override this default behaviour by creating a parallel collection which shares the same underlying dataset. For these collections, par takes constant or sublinear time.

    All parallel collections return a reference to themselves.

    returns

    a parallel implementation of this collection

    Definition Classes
    ParIterableLikeCustomParallelizableParallelizable
  70. def partition(pred: ((K, V)) => Boolean): (ParMap[K, V], ParMap[K, V])
    Definition Classes
    ParIterableLike
  71. def product[U >: (K, V)](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike
  72. def reduce[U >: (K, V)](op: (U, U) => U): U

    Reduces the elements of this sequence using the specified associative binary operator.

    Reduces the elements of this sequence using the specified associative binary operator.

    The order in which operations are performed on elements is unspecified and may be nondeterministic.

    Note this method has a different signature than the reduceLeft and reduceRight methods of the trait Traversable. The result of reducing may only be a supertype of this parallel collection's type parameter T.

    U

    A type parameter for the binary operator, a supertype of T.

    op

    A binary operator that must be associative.

    returns

    The result of applying reduce operator op between all the elements if the collection is nonempty.

    Definition Classes
    ParIterableLike
    Exceptions thrown

    UnsupportedOperationException if this parallel map is empty.

  73. def reduceLeft[U >: (K, V)](op: (U, (K, V)) => U): U
    Definition Classes
    ParIterableLike
  74. def reduceLeftOption[U >: (K, V)](op: (U, (K, V)) => U): Option[U]
    Definition Classes
    ParIterableLike
  75. def reduceOption[U >: (K, V)](op: (U, U) => U): Option[U]

    Optionally reduces the elements of this sequence using the specified associative binary operator.

    Optionally reduces the elements of this sequence using the specified associative binary operator.

    The order in which operations are performed on elements is unspecified and may be nondeterministic.

    Note this method has a different signature than the reduceLeftOption and reduceRightOption methods of the trait Traversable. The result of reducing may only be a supertype of this parallel collection's type parameter T.

    U

    A type parameter for the binary operator, a supertype of T.

    op

    A binary operator that must be associative.

    returns

    An option value containing result of applying reduce operator op between all the elements if the collection is nonempty, and None otherwise.

    Definition Classes
    ParIterableLike
  76. def reduceRight[U >: (K, V)](op: ((K, V), U) => U): U
    Definition Classes
    ParIterableLike
  77. def reduceRightOption[U >: (K, V)](op: ((K, V), U) => U): Option[U]
    Definition Classes
    ParIterableLike
  78. def repr: ParMap[K, V]
    Definition Classes
    ParIterableLike
  79. def sameElements[U >: (K, V)](that: scala.IterableOnce[U]): Boolean
    Definition Classes
    ParIterableLike
  80. def scan[U >: (K, V)](z: U)(op: (U, U) => U): ParIterable[U]

    Computes a prefix scan of the elements of the collection.

    Computes a prefix scan of the elements of the collection.

    Note: The neutral element z may be applied more than once.

    U

    element type of the resulting collection

    z

    neutral element for the operator op

    op

    the associative operator for the scan

    returns

    a new parallel map containing the prefix scan of the elements in this parallel map

    Definition Classes
    ParIterableLike
  81. def scanLeft[S](z: S)(op: (S, (K, V)) => S): scala.Iterable[S]
    Definition Classes
    ParIterableLike
  82. def scanRight[S](z: S)(op: ((K, V), S) => S): scala.Iterable[S]
    Definition Classes
    ParIterableLike
  83. def slice(unc_from: Int, unc_until: Int): ParMap[K, V]
    Definition Classes
    ParIterableLike
  84. def span(pred: ((K, V)) => Boolean): (ParMap[K, V], ParMap[K, V])

    Splits this parallel map into a prefix/suffix pair according to a predicate.

    Splits this parallel map into a prefix/suffix pair according to a predicate.

    This method will use indexFlag signalling capabilities. This means that splitters may set and read the indexFlag state. The index flag is initially set to maximum integer value.

    pred

    the predicate used to test the elements

    returns

    a pair consisting of the longest prefix of the collection for which all the elements satisfy pred, and the rest of the collection

    Definition Classes
    ParIterableLike
  85. def splitAt(n: Int): (ParMap[K, V], ParMap[K, V])
    Definition Classes
    ParIterableLike
  86. def stepper[S <: Stepper[_]](implicit shape: StepperShape[(K, V) @scala.annotation.unchecked.uncheckedVariance, S]): S
    Definition Classes
    IterableOnce
  87. def stringPrefix: String
    Definition Classes
    ParMapParMapParIterableParIterableLike
  88. def sum[U >: (K, V)](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike
  89. def tail: ParMap[K, V]
    Definition Classes
    ParIterableLike
  90. def take(n: Int): ParMap[K, V]
    Definition Classes
    ParIterableLike
  91. def takeWhile(pred: ((K, V)) => Boolean): ParMap[K, V]

    Takes the longest prefix of elements that satisfy the predicate.

    Takes the longest prefix of elements that satisfy the predicate.

    This method will use indexFlag signalling capabilities. This means that splitters may set and read the indexFlag state. The index flag is initially set to maximum integer value.

    pred

    the predicate used to test the elements

    returns

    the longest prefix of this parallel map of elements that satisfy the predicate pred

    Definition Classes
    ParIterableLike
  92. def tasksupport: TaskSupport

    The task support object which is responsible for scheduling and load-balancing tasks to processors.

    The task support object which is responsible for scheduling and load-balancing tasks to processors.

    Definition Classes
    ParIterableLike
    See also

    scala.collection.parallel.TaskSupport

  93. def tasksupport_=(ts: TaskSupport): Unit

    Changes the task support object which is responsible for scheduling and load-balancing tasks to processors.

    Changes the task support object which is responsible for scheduling and load-balancing tasks to processors.

    A task support object can be changed in a parallel collection after it has been created, but only during a quiescent period, i.e. while there are no concurrent invocations to parallel collection methods.

    Here is a way to change the task support of a parallel collection:

    import scala.collection.parallel._
    val pc = mutable.ParArray(1, 2, 3)
    pc.tasksupport = new ForkJoinTaskSupport(
      new java.util.concurrent.ForkJoinPool(2))
    Definition Classes
    ParIterableLike
    See also

    scala.collection.parallel.TaskSupport

  94. def to[C](factory: Factory[(K, V), C]): C
    Definition Classes
    ParIterableLike
  95. def toArray[U >: (K, V)](implicit arg0: ClassTag[U]): Array[U]
    Definition Classes
    ParIterableLike
  96. def toBuffer[U >: (K, V)]: Buffer[U]
    Definition Classes
    ParIterableLike
  97. def toIndexedSeq: immutable.IndexedSeq[(K, V)]
    Definition Classes
    ParIterableLike
  98. def toIterable: ParIterable[(K, V)]
    Definition Classes
    ParIterableParIterableLike
  99. def toIterator: scala.Iterator[(K, V)]
    Definition Classes
    ParIterableLike
  100. def toList: List[(K, V)]
    Definition Classes
    ParIterableLike
  101. def toMap[P, Q](implicit ev: <:<[(K, V), (P, Q)]): ParMap[P, Q]
    Definition Classes
    ParMapLikeParIterableLike
  102. def toSeq: ParSeq[(K, V)]
    Definition Classes
    ParIterableParIterableLike
  103. def toSet[U >: (K, V)]: ParSet[U]
    Definition Classes
    ParIterableLike
  104. def toString(): String
    Definition Classes
    ParIterableLike → AnyRef → Any
  105. def toVector: Vector[(K, V)]
    Definition Classes
    ParIterableLike
  106. def transpose[B](implicit asTraversable: ((K, V)) => scala.IterableOnce[B]): ParIterable[ParIterable[B]]

    Transposes this parallel map of traversable collections into a parallel map of parallel maps.

    Transposes this parallel map of traversable collections into a parallel map of parallel maps.

    The resulting collection's type will be guided by the static type of parallel map. For example:

    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))
    B

    the type of the elements of each traversable collection.

    asTraversable

    an implicit conversion which asserts that the element type of this parallel map is a Traversable.

    returns

    a two-dimensional parallel map of parallel maps which has as nth row the nth column of this parallel map.

    Definition Classes
    GenericTraversableTemplate
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.

    Exceptions thrown

    IllegalArgumentException if all collections in this parallel map are not of the same size.

  107. def unzip[A1, A2](implicit asPair: ((K, V)) => (A1, A2)): (ParIterable[A1], ParIterable[A2])

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

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

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

    the type of the first half of the element pairs

    A2

    the type of the second half of the element pairs

    asPair

    an implicit conversion which asserts that the element type of this parallel map is a pair.

    returns

    a pair of parallel maps, containing the first, respectively second half of each element pair of this parallel map.

    Definition Classes
    GenericTraversableTemplate
  108. def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) => (A1, A2, A3)): (ParIterable[A1], ParIterable[A2], ParIterable[A3])

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

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

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

    the type of the first member of the element triples

    A2

    the type of the second member of the element triples

    A3

    the type of the third member of the element triples

    asTriple

    an implicit conversion which asserts that the element type of this parallel map is a triple.

    returns

    a triple of parallel maps, containing the first, second, respectively third member of each element triple of this parallel map.

    Definition Classes
    GenericTraversableTemplate
  109. def updated[U >: V](key: K, value: U): ParMap[K, U]
    Definition Classes
    ParMapLikeParMapLike
  110. def values: parallel.ParIterable[V]
    Definition Classes
    ParMapLike
  111. def valuesIterator: IterableSplitter[V]
    Definition Classes
    ParMapLike
  112. def withDefault[U >: V](d: (K) => U): ParMap[K, U]

    The same map with a given default function.

    The same map with a given default function. Note: get, contains, iterator, keys, etc are not affected by withDefault.

    Invoking transformer methods (e.g. map) will not preserve the default value.

    d

    the function mapping keys to values, used for non-present keys

    returns

    a wrapper of the map with a default value

  113. def withDefaultValue[U >: V](d: U): ParMap[K, U]

    The same map with a given default value.

    The same map with a given default value.

    Invoking transformer methods (e.g. map) will not preserve the default value.

    d

    default value used for non-present keys

    returns

    a wrapper of the map with a default value

  114. def withFilter(pred: ((K, V)) => Boolean): ParMap[K, V]
    Definition Classes
    ParIterableLike
  115. def zip[U >: (K, V), S](that: scala.Iterable[S]): ParIterable[(U, S)]
    Definition Classes
    ParIterableLike
  116. def zip[U >: (K, V), S](that: parallel.ParIterable[S]): ParIterable[(U, S)]
    Definition Classes
    ParIterableLike
  117. def zipAll[S, U >: (K, V)](that: parallel.ParIterable[S], thisElem: U, thatElem: S): ParIterable[(U, S)]
    Definition Classes
    ParIterableLike
  118. def zipWithIndex[U >: (K, V)]: ParIterable[(U, Int)]

    Zips this parallel map with its indices.

    Zips this parallel map with its indices.

    U

    the type of the first half of the returned pairs (this is always a supertype of the collection's element type T).

    returns

    A new collection of type ParMap containing pairs consisting of all elements of this parallel map paired with their index. Indices start at 0.

    Definition Classes
    ParIterableLike

Deprecated Value Members

  1. def toStream: Stream[(K, V)]
    Definition Classes
    ParIterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.3) Use to(LazyList) instead.

  2. def toTraversable: parallel.ParIterable[(K, V)]
    Definition Classes
    ParIterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.3) Use toIterable instead