WithDefault

Standard accessor task that iterates over the elements of the collection.

Alias for concat

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

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

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.

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.

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

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

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

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.

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

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

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.

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

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

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

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.

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.

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

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.

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.

Optionally reuses an existing combiner for better performance. By default it doesn't - subclasses may override this behaviour. The provided combiner oldc that can potentially be reused will be either some combiner from the previous computational task, or None if there was no previous phase (in which case this method must return newc).

Computes a prefix scan of the elements of the collection.

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

Splits this parallel iterable 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.

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.

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

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

The resulting collection's type will be guided by the static type of collection. 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))

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

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

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

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

Zips this parallel iterable with its indices.