Packages

class ParRange extends ParSeq[Int] with Serializable

Parallel ranges.

This is a base trait for Scala parallel collections. It defines behaviour common to all parallel collections. Concrete parallel collections should inherit this trait and ParIterable if they want to define specific combiner factories.

Parallel operations are implemented with divide and conquer style algorithms that parallelize well. The basic idea is to split the collection into smaller parts until they are small enough to be operated on sequentially.

All of the parallel operations are implemented as tasks within this trait. Tasks rely on the concept of splitters, which extend iterators. Every parallel collection defines:

def splitter: IterableSplitter[T]

which returns an instance of IterableSplitter[T], which is a subtype of Splitter[T]. Splitters have a method remaining to check the remaining number of elements, and method split which is defined by splitters. Method split divides the splitters iterate over into disjunct subsets:

def split: Seq[Splitter]

which splits the splitter into a sequence of disjunct subsplitters. This is typically a very fast operation which simply creates wrappers around the receiver collection. This can be repeated recursively.

Tasks are scheduled for execution through a scala.collection.parallel.TaskSupport object, which can be changed through the tasksupport setter of the collection.

Method newCombiner produces a new combiner. Combiners are an extension of builders. They provide a method combine which combines two combiners and returns a combiner containing elements of both combiners. This method can be implemented by aggressively copying all the elements into the new combiner or by lazily binding their results. It is recommended to avoid copying all of the elements for performance reasons, although that cost might be negligible depending on the use case. Standard parallel collection combiners avoid copying when merging results, relying either on a two-step lazy construction or specific data-structure properties.

Methods:

def seq: Sequential
def par: Repr

produce the sequential or parallel implementation of the collection, respectively. Method par just returns a reference to this parallel collection. Method seq is efficient - it will not copy the elements. Instead, it will create a sequential version of the collection using the same underlying data structure. Note that this is not the case for sequential collections in general - they may copy the elements and produce a different underlying data structure.

The combination of methods toMap, toSeq or toSet along with par and seq is a flexible way to change between different collection types.

Since this trait extends the GenIterable trait, methods like size must also be implemented in concrete collections, while iterator forwards to splitter by default.

Each parallel collection is bound to a specific fork/join pool, on which dormant worker threads are kept. The fork/join pool contains other information such as the parallelism level, that is, the number of processors used. When a collection is created, it is assigned the default fork/join pool found in the scala.parallel package object.

Parallel collections are not necessarily ordered in terms of the foreach operation (see Traversable). Parallel sequences have a well defined order for iterators - creating an iterator and traversing the elements linearly will always yield the same order. However, bulk operations such as foreach, map or filter always occur in undefined orders for all parallel collections.

Existing parallel collection implementations provide strict parallel iterators. Strict parallel iterators are aware of the number of elements they have yet to traverse. It's also possible to provide non-strict parallel iterators, which do not know the number of elements remaining. To do this, the new collection implementation must override isStrictSplitterCollection to false. This will make some operations unavailable.

To create a new parallel collection, extend the ParIterable trait, and implement size, splitter, newCombiner and seq. Having an implicit combiner factory requires extending this trait in addition, as well as providing a companion object, as with regular collections.

Method size is implemented as a constant time operation for parallel collections, and parallel collection operations rely on this assumption.

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.

Self Type
ParRange
Annotations
@SerialVersionUID()
Since

2.9

See also

Scala's Parallel Collections Library overview section on ParRange for more information.

Linear Supertypes
Serializable, java.io.Serializable, ParSeq[Int], ParIterable[Int], Immutable, parallel.ParSeq[Int], ParSeqLike[Int, ParSeq[Int], immutable.Seq[Int]], parallel.ParIterable[Int], ParIterableLike[Int, ParSeq[Int], immutable.Seq[Int]], Parallel, CustomParallelizable[Int, ParSeq[Int]], Parallelizable[Int, ParSeq[Int]], GenericParTemplate[Int, ParSeq], HasNewCombiner[Int, scala.collection.parallel.immutable.ParSeq[Int] @scala.annotation.unchecked.uncheckedVariance], GenSeq[Int], GenIterable[Int], GenTraversable[Int], GenericTraversableTemplate[Int, ParSeq], HasNewBuilder[Int, scala.collection.parallel.immutable.ParSeq[Int] @scala.annotation.unchecked.uncheckedVariance], GenSeqLike[Int, ParSeq[Int]], Equals, GenIterableLike[Int, ParSeq[Int]], GenTraversableLike[Int, ParSeq[Int]], GenTraversableOnce[Int], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ParRange
  2. Serializable
  3. Serializable
  4. ParSeq
  5. ParIterable
  6. Immutable
  7. ParSeq
  8. ParSeqLike
  9. ParIterable
  10. ParIterableLike
  11. Parallel
  12. CustomParallelizable
  13. Parallelizable
  14. GenericParTemplate
  15. HasNewCombiner
  16. GenSeq
  17. GenIterable
  18. GenTraversable
  19. GenericTraversableTemplate
  20. HasNewBuilder
  21. GenSeqLike
  22. Equals
  23. GenIterableLike
  24. GenTraversableLike
  25. GenTraversableOnce
  26. AnyRef
  27. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ParRange(range: immutable.Range)

    range

    the sequential range this parallel range was obtained from

Type Members

  1. class Aggregate [S] extends Accessor[S, Aggregate[S]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  2. trait BuilderOps [Elem, To] extends AnyRef
    Definition Classes
    ParIterableLike
  3. class Collect [S, That] extends Transformer[Combiner[S, That], Collect[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  4. abstract class Composite [FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends NonDivisibleTask[R, Composite[FR, SR, R, First, Second]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  5. class Copy [U >: T, That] extends Transformer[Combiner[U, That], Copy[U, That]]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  6. class CopyToArray [U >: T, This >: Repr] extends Accessor[Unit, CopyToArray[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  7. class Count extends Accessor[Int, Count]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  8. class CreateScanTree [U >: T] extends Transformer[ScanTree[U], CreateScanTree[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  9. class Drop [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Drop[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  10. class Exists extends Accessor[Boolean, Exists]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  11. class Filter [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Filter[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  12. class FilterNot [U >: T, This >: Repr] extends Transformer[Combiner[U, This], FilterNot[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  13. class Find [U >: T] extends Accessor[Option[U], Find[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  14. class FlatMap [S, That] extends Transformer[Combiner[S, That], FlatMap[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  15. class Fold [U >: T] extends Accessor[U, Fold[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  16. class Forall extends Accessor[Boolean, Forall]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  17. class Foreach [S] extends Accessor[Unit, Foreach[S]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  18. class FromScanTree [U >: T, That] extends StrictSplitterCheckTask[Combiner[U, That], FromScanTree[U, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  19. class GroupBy [K, U >: T] extends Transformer[HashMapCombiner[K, U], GroupBy[K, U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  20. class Map [S, That] extends Transformer[Combiner[S, That], Map[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  21. class Max [U >: T] extends Accessor[Option[U], Max[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  22. class Min [U >: T] extends Accessor[Option[U], Min[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  23. trait NonDivisible [R] extends NonDivisibleTask[R, NonDivisible[R]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  24. trait NonDivisibleTask [R, Tp] extends StrictSplitterCheckTask[R, Tp]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  25. abstract class ParComposite [FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

    Performs two tasks in parallel, and waits for both to finish.

    Performs two tasks in parallel, and waits for both to finish.

    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  26. class Partition [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Partition[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  27. class Product [U >: T] extends Accessor[U, Product[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  28. class Reduce [U >: T] extends Accessor[Option[U], Reduce[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  29. abstract class ResultMapping [R, Tp, R1] extends NonDivisibleTask[R1, ResultMapping[R, Tp, R1]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  30. case class ScanLeaf [U >: T](pit: IterableSplitter[U], op: (U, U) ⇒ U, from: Int, len: Int, prev: Option[ScanLeaf[U]], acc: U) extends ScanTree[U] with scala.Product with Serializable
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  31. case class ScanNode [U >: T](left: ScanTree[U], right: ScanTree[U]) extends ScanTree[U] with scala.Product with Serializable
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  32. trait ScanTree [U >: T] extends AnyRef
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  33. abstract class SeqComposite [FR, SR, R, First <: StrictSplitterCheckTask[FR, _], Second <: StrictSplitterCheckTask[SR, _]] extends Composite[FR, SR, R, First, Second]

    Sequentially performs one task after another.

    Sequentially performs one task after another.

    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  34. trait SignallingOps [PI <: DelegatedSignalling] extends AnyRef
    Definition Classes
    ParIterableLike
  35. class Slice [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Slice[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  36. class Span [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), Span[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  37. class SplitAt [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Combiner[U, This]), SplitAt[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  38. trait StrictSplitterCheckTask [R, Tp] extends Task[R, Tp]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  39. class Sum [U >: T] extends Accessor[U, Sum[U]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  40. class Take [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Take[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  41. class TakeWhile [U >: T, This >: Repr] extends Transformer[(Combiner[U, This], Boolean), TakeWhile[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  42. trait TaskOps [R, Tp] extends AnyRef
    Definition Classes
    ParIterableLike
  43. class ToParCollection [U >: T, That] extends Transformer[Combiner[U, That], ToParCollection[U, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  44. class ToParMap [K, V, That] extends Transformer[Combiner[(K, V), That], ToParMap[K, V, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  45. class ZipAll [U >: T, S, That] extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  46. trait Accessor [R, Tp] extends ParSeqLike.Accessor[R, Tp]
    Attributes
    protected
    Definition Classes
    ParSeqLike
  47. class Corresponds [S] extends Accessor[Boolean, Corresponds[S]]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  48. abstract class Elements extends SeqSplitter[T] with scala.BufferedIterator[T]

    Used to iterate elements using indices

    Used to iterate elements using indices

    Attributes
    protected
    Definition Classes
    ParSeqLike
  49. class IndexWhere extends Accessor[Int, IndexWhere]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  50. class LastIndexWhere extends Accessor[Int, LastIndexWhere]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  51. class Reverse [U >: T, This >: Repr] extends Transformer[Combiner[U, This], Reverse[U, This]]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  52. class ReverseMap [S, That] extends Transformer[Combiner[S, That], ReverseMap[S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  53. class SameElements [U >: T] extends Accessor[Boolean, SameElements[U]]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  54. class SegmentLength extends Accessor[(Int, Boolean), SegmentLength]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  55. trait Transformer [R, Tp] extends Accessor[R, Tp] with ParSeqLike.Transformer[R, Tp]
    Attributes
    protected
    Definition Classes
    ParSeqLike
  56. class Updated [U >: T, That] extends Transformer[Combiner[U, That], Updated[U, That]]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  57. class Zip [U >: T, S, That] extends Transformer[Combiner[(U, S), That], Zip[U, S, That]]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  58. class ParRangeIterator extends SeqSplitter[Int]
  59. type SSCTask[R, Tp] = StrictSplitterCheckTask[R, Tp]
    Definition Classes
    ParIterableLike
  60. type SuperParIterator = IterableSplitter[Int]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def ++[U >: Int, That](that: GenTraversableOnce[U])(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  4. def +:[U >: Int, That](elem: U)(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That
    Definition Classes
    ParSeqLike → GenSeqLike
  5. def /:[S](z: S)(op: (S, Int) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  6. def :+[U >: Int, That](elem: U)(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That
    Definition Classes
    ParSeqLike → GenSeqLike
  7. def :\[S](z: S)(op: (Int, S) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  8. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def aggregate[S](z: ⇒ S)(seqop: (S, Int) ⇒ 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 → GenTraversableOnce
  10. final def apply(idx: Int): Int
    Definition Classes
    ParRange → ParSeq → GenSeqLike
    Annotations
    @inline()
  11. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  12. def bf2seq[S, That](bf: CanBuildFrom[ParSeq[Int], S, That]): CanBuildFrom[immutable.Seq[Int], S, That]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  13. implicit def builder2ops[Elem, To](cb: Builder[Elem, To]): BuilderOps[Elem, To]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  14. def canEqual(other: Any): Boolean
    Definition Classes
    ParIterableLike
  15. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  16. def collect[S, That](pf: PartialFunction[Int, S])(implicit bf: CanBuildFrom[ParSeq[Int], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  17. def combinerFactory[S, That](cbf: () ⇒ Combiner[S, That]): CombinerFactory[S, That]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  18. def combinerFactory: CombinerFactory[Int, ParSeq[Int]]

    Creates a combiner factory.

    Creates a combiner factory. Each combiner factory instance is used once per invocation of a parallel transformer method for a single collection.

    The default combiner factory creates a new combiner every time it is requested, unless the combiner is thread-safe as indicated by its canBeShared method. In this case, the method returns a factory which returns the same combiner each time. This is typically done for concurrent parallel collections, the combiners of which allow thread safe access.

    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  19. def companion: GenericCompanion[ParSeq] with GenericParCompanion[ParSeq]
    Definition Classes
    ParSeq → ParIterable → ParSeq → ParIterable → GenericParTemplate → GenSeq → GenIterable → GenTraversable → GenericTraversableTemplate
  20. def copyToArray[U >: Int](xs: Array[U], start: Int, len: Int): Unit
    Definition Classes
    ParIterableLike → GenTraversableOnce
  21. def copyToArray[U >: Int](xs: Array[U], start: Int): Unit
    Definition Classes
    ParIterableLike → GenTraversableOnce
  22. def copyToArray[U >: Int](xs: Array[U]): Unit
    Definition Classes
    ParIterableLike → GenTraversableOnce
  23. def corresponds[S](that: GenSeq[S])(p: (Int, S) ⇒ Boolean): Boolean

    Tests whether every element of this parallel iterable relates to the corresponding element of another parallel sequence by satisfying a test predicate.

    Tests whether every element of this parallel iterable relates to the corresponding element of another parallel sequence by satisfying a test predicate.

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

    S

    the type of the elements of that

    that

    the other parallel sequence

    p

    the test predicate, which relates elements from both sequences

    returns

    true if both parallel sequences have the same length and p(x, y) is true for all corresponding elements x of this parallel iterable and y of that, otherwise false

    Definition Classes
    ParSeqLike → GenSeqLike
  24. def count(p: (Int) ⇒ Boolean): Int
    Definition Classes
    ParIterableLike → GenTraversableOnce
  25. def debugBuffer: ArrayBuffer[String]
    Definition Classes
    ParIterableLike
  26. implicit def delegatedSignalling2ops[PI <: DelegatedSignalling](it: PI): SignallingOps[PI]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  27. def diff[U >: Int](that: GenSeq[U]): ParSeq[Int]
    Definition Classes
    ParSeqLike → GenSeqLike
  28. def distinct: ParSeq[Int]

    Builds a new parallel iterable from this parallel iterable without any duplicate elements.

    Builds a new parallel iterable from this parallel iterable without any duplicate elements.

    Note: will not terminate for infinite-sized collections.

    This trait defines a new, more general split operation and reimplements the split operation of ParallelIterable trait using the new split operation.

    returns

    A new parallel iterable which contains the first occurrence of every element of this parallel iterable.

    Definition Classes
    ParSeqLike → GenSeqLike
  29. def down(p: IterableSplitter[_]): SeqSplitter[Int]
    Attributes
    protected[this]
    Definition Classes
    ParSeqLike
  30. def drop(n: Int): ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  31. def dropWhile(pred: (Int) ⇒ Boolean): ParSeq[Int]

    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 iterable that satisfy the predicate pred

    Definition Classes
    ParIterableLike → GenTraversableLike
  32. def endsWith[S](that: GenSeq[S]): Boolean

    Tests whether this parallel iterable ends with the given parallel sequence.

    Tests whether this parallel iterable ends with the given parallel sequence.

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

    S

    the type of the elements of that sequence

    that

    the sequence to test

    returns

    true if this parallel iterable has that as a suffix, false otherwise

    Definition Classes
    ParSeqLike → GenSeqLike
  33. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  34. def equals(that: Any): Boolean
    Definition Classes
    GenSeqLike → Equals → Any
  35. def exists(p: (Int) ⇒ Boolean): Boolean

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

    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.

    p

    a predicate used to test elements

    returns

    true if p holds for some element, false otherwise

    Definition Classes
    ParIterableLike → GenTraversableOnce
  36. def filter(pred: (Int) ⇒ Boolean): ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  37. def filterNot(pred: (Int) ⇒ Boolean): ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  38. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  39. def find(p: (Int) ⇒ Boolean): Option[Int]

    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 → GenTraversableOnce
  40. def flatMap[S, That](f: (Int) ⇒ GenTraversableOnce[S])(implicit bf: CanBuildFrom[ParSeq[Int], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  41. def flatten[B](implicit asTraversable: (Int) ⇒ GenTraversableOnce[B]): ParSeq[B]
    Definition Classes
    GenericTraversableTemplate
  42. def fold[U >: Int](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 → GenTraversableOnce
  43. def foldLeft[S](z: S)(op: (S, Int) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  44. def foldRight[S](z: S)(op: (Int, S) ⇒ S): S
    Definition Classes
    ParIterableLike → GenTraversableOnce
  45. def forall(p: (Int) ⇒ Boolean): Boolean

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

    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.

    p

    a predicate used to test elements

    returns

    true if p holds for all elements, false otherwise

    Definition Classes
    ParIterableLike → GenTraversableOnce
  46. def foreach[U](f: (Int) ⇒ U): Unit

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

    Applies a function f to all the elements of parallel iterable 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 → GenTraversableLike → GenTraversableOnce
  47. def genericBuilder[B]: Combiner[B, ParSeq[B]]
    Definition Classes
    GenericParTemplate → GenericTraversableTemplate
  48. def genericCombiner[B]: Combiner[B, ParSeq[B]]
    Definition Classes
    GenericParTemplate
  49. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  50. def groupBy[K](f: (Int) ⇒ K): ParMap[K, ParSeq[Int]]
    Definition Classes
    ParIterableLike → GenTraversableLike
  51. def hasDefiniteSize: Boolean
    Definition Classes
    ParIterableLike → GenTraversableOnce
  52. def hashCode(): Int
    Definition Classes
    GenSeqLike → Any
  53. def head: Int
    Definition Classes
    ParIterableLike → GenTraversableLike
  54. def headOption: Option[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  55. def indexOf[B >: Int](elem: B, from: Int): Int
    Definition Classes
    GenSeqLike
  56. def indexOf[B >: Int](elem: B): Int
    Definition Classes
    GenSeqLike
  57. def indexWhere(p: (Int) ⇒ Boolean, from: Int): Int

    Finds the first element satisfying some predicate.

    Finds the first element satisfying some 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.

    p

    the predicate used to test the elements

    from

    the starting offset for the search

    returns

    the index >= from of the first element of this parallel iterable that satisfies the predicate p, or -1, if none exists

    Definition Classes
    ParSeqLike → GenSeqLike
  58. def indexWhere(p: (Int) ⇒ Boolean): Int
    Definition Classes
    GenSeqLike
  59. def init: ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  60. def initTaskSupport(): Unit
    Attributes
    protected
    Definition Classes
    ParIterableLike
  61. def intersect(that: scala.Seq[Int]): ParRange[Int]

    [use case] Computes the multiset intersection between this immutable parallel range and another sequence.

    [use case]

    Computes the multiset intersection between this immutable parallel range and another sequence.

    Note: may not terminate for infinite-sized collections.

    that

    the sequence of elements to intersect with.

    returns

    a new immutable parallel range which contains all elements of this immutable parallel range which also appear in that. If an element value x appears n times in that, then the first n occurrences of x will be retained in the result, but any following occurrences will be omitted.

    Definition Classes
    ParSeqLike → GenSeqLike
    Full Signature

    def intersect[U >: Int](that: GenSeq[U]): ParSeq[Int]

  62. def isDefinedAt(idx: Int): Boolean
    Definition Classes
    GenSeqLike
  63. def isEmpty: Boolean
    Definition Classes
    ParIterableLike → GenTraversableOnce
  64. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  65. 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
  66. final def isTraversableAgain: Boolean
    Definition Classes
    ParIterableLike → GenTraversableLike → GenTraversableOnce
  67. def iterator: PreciseSplitter[Int]

    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
    ParSeqLike → ParIterableLike → GenIterableLike
  68. def last: Int
    Definition Classes
    ParIterableLike → GenTraversableLike
  69. def lastIndexOf[B >: Int](elem: B, end: Int): Int
    Definition Classes
    GenSeqLike
  70. def lastIndexOf[B >: Int](elem: B): Int
    Definition Classes
    GenSeqLike
  71. def lastIndexWhere(p: (Int) ⇒ Boolean, end: Int): Int

    Finds the last element satisfying some predicate.

    Finds the last element satisfying some 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 minimum integer value.

    p

    the predicate used to test the elements

    end

    the maximum offset for the search

    returns

    the index <= end of the first element of this parallel iterable that satisfies the predicate p, or -1, if none exists

    Definition Classes
    ParSeqLike → GenSeqLike
  72. def lastIndexWhere(p: (Int) ⇒ Boolean): Int
    Definition Classes
    GenSeqLike
  73. def lastOption: Option[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  74. final def length: Int
    Definition Classes
    ParRange → GenSeqLike
    Annotations
    @inline()
  75. def map[S, That](f: (Int) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[Int], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  76. def max[U >: Int](implicit ord: Ordering[U]): Int
    Definition Classes
    ParIterableLike → GenTraversableOnce
  77. def maxBy[S](f: (Int) ⇒ S)(implicit cmp: Ordering[S]): Int
    Definition Classes
    ParIterableLike → GenTraversableOnce
  78. def min[U >: Int](implicit ord: Ordering[U]): Int
    Definition Classes
    ParIterableLike → GenTraversableOnce
  79. def minBy[S](f: (Int) ⇒ S)(implicit cmp: Ordering[S]): Int
    Definition Classes
    ParIterableLike → GenTraversableOnce
  80. def mkString: String
    Definition Classes
    ParIterableLike → GenTraversableOnce
  81. def mkString(sep: String): String
    Definition Classes
    ParIterableLike → GenTraversableOnce
  82. def mkString(start: String, sep: String, end: String): String
    Definition Classes
    ParIterableLike → GenTraversableOnce
  83. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  84. def newBuilder: Builder[Int, ParSeq[Int]]
    Attributes
    protected[this]
    Definition Classes
    GenericParTemplate → GenericTraversableTemplate → HasNewBuilder
  85. def newCombiner: Combiner[Int, ParSeq[Int]]
    Attributes
    protected[this]
    Definition Classes
    GenericParTemplate → HasNewCombiner
  86. def nonEmpty: Boolean
    Definition Classes
    ParIterableLike → GenTraversableOnce
  87. final def notify(): Unit
    Definition Classes
    AnyRef
  88. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  89. def padTo[U >: Int, That](len: Int, elem: U)(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That
    Definition Classes
    ParSeqLike → GenSeqLike
  90. def par: ParSeq[Int]

    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
    ParIterableLike → CustomParallelizable → Parallelizable
  91. def parCombiner: Combiner[Int, ParSeq[Int]]

    The default par implementation uses the combiner provided by this method to create a new parallel collection.

    The default par implementation uses the combiner provided by this method to create a new parallel collection.

    returns

    a combiner for the parallel collection of type ParRepr

    Attributes
    protected[this]
    Definition Classes
    CustomParallelizable → Parallelizable
  92. def partition(pred: (Int) ⇒ Boolean): (ParSeq[Int], ParSeq[Int])
    Definition Classes
    ParIterableLike → GenTraversableLike
  93. def patch[U >: Int, That](from: Int, patch: GenSeq[U], replaced: Int)(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That
    Definition Classes
    ParSeqLike → GenSeqLike
  94. def prefixLength(p: (Int) ⇒ Boolean): Int
    Definition Classes
    GenSeqLike
  95. def product[U >: Int](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike → GenTraversableOnce
  96. val range: immutable.Range
  97. def reduce[U >: Int](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 → GenTraversableOnce
    Exceptions thrown

    UnsupportedOperationException if this parallel iterable is empty.

  98. def reduceLeft[U >: Int](op: (U, Int) ⇒ U): U
    Definition Classes
    ParIterableLike
  99. def reduceLeftOption[U >: Int](op: (U, Int) ⇒ U): Option[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  100. def reduceOption[U >: Int](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 → GenTraversableOnce
  101. def reduceRight[U >: Int](op: (Int, U) ⇒ U): U
    Definition Classes
    ParIterableLike → GenTraversableOnce
  102. def reduceRightOption[U >: Int](op: (Int, U) ⇒ U): Option[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  103. def repr: ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  104. def reuse[S, That](oldc: Option[Combiner[S, That]], newc: Combiner[S, That]): Combiner[S, That]

    Optionally reuses an existing combiner for better performance.

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

    oldc

    The combiner that is the result of the previous task, or None if there was no previous task.

    newc

    The new, empty combiner that can be used.

    returns

    Either newc or oldc.

    Attributes
    protected
    Definition Classes
    ParIterableLike
  105. def reverse: ParSeq[Int]
    Definition Classes
    ParSeqLike → GenSeqLike
  106. def reverseMap[S, That](f: (Int) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[Int], S, That]): That
    Definition Classes
    ParSeqLike → GenSeqLike
  107. def sameElements[U >: Int](that: GenIterable[U]): Boolean
    Definition Classes
    ParSeqLike → ParIterableLike → GenIterableLike
  108. def scan(z: Int)(op: (Int, Int) ⇒ Int): ParRange[Int]

    [use case] Computes a prefix scan of the elements of the collection.

    [use case]

    Computes a prefix scan of the elements of the collection.

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

    z

    neutral element for the operator op

    op

    the associative operator for the scan

    returns

    a new immutable parallel range containing the prefix scan of the elements in this immutable parallel range

    Definition Classes
    ParIterableLike → GenTraversableLike
    Full Signature

    def scan[U >: Int, That](z: U)(op: (U, U) ⇒ U)(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That

  109. def scanBlockSize: Int
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  110. def scanLeft[S, That](z: S)(op: (S, Int) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[Int], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  111. def scanRight[S, That](z: S)(op: (Int, S) ⇒ S)(implicit bf: CanBuildFrom[ParSeq[Int], S, That]): That
    Definition Classes
    ParIterableLike → GenTraversableLike
  112. def segmentLength(p: (Int) ⇒ Boolean, from: Int): Int

    Returns the length of the longest segment of elements starting at a given position satisfying some predicate.

    Returns the length of the longest segment of elements starting at a given position satisfying some 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.

    p

    the predicate used to test the elements

    from

    the starting offset for the search

    returns

    the length of the longest segment of elements starting at from and satisfying the predicate

    Definition Classes
    ParSeqLike → GenSeqLike
  113. def seq: immutable.Range
    Definition Classes
    ParRange → ParIterableLike → Parallelizable → GenSeq → GenIterable → GenTraversable → GenSeqLike → GenTraversableOnce
  114. def sequentially[S, That <: Parallel](b: (immutable.Seq[Int]) ⇒ immutable.Seq[Int]): ParSeq[Int]
    Attributes
    protected[this]
    Definition Classes
    ParIterableLike
  115. def size: Int
    Definition Classes
    ParSeqLike → GenTraversableLike → GenTraversableOnce
  116. def sizeHintIfCheap: Int
    Attributes
    protected[scala.collection]
    Definition Classes
    GenTraversableOnce
  117. def slice(unc_from: Int, unc_until: Int): ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  118. def span(pred: (Int) ⇒ Boolean): (ParSeq[Int], ParSeq[Int])

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

    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.

    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 → GenTraversableLike
  119. def splitAt(n: Int): (ParSeq[Int], ParSeq[Int])
    Definition Classes
    ParIterableLike → GenTraversableLike
  120. def splitter: ParRangeIterator

    A more refined version of the iterator found in the ParallelIterable trait, this iterator can be split into arbitrary subsets of iterators.

    A more refined version of the iterator found in the ParallelIterable trait, this iterator can be split into arbitrary subsets of iterators.

    returns

    an iterator that can be split into subsets of precise size

    Definition Classes
    ParRange → ParSeqLike → ParIterableLike
  121. def startsWith[S](that: GenSeq[S], offset: Int): Boolean

    Tests whether this parallel iterable contains the given sequence at a given index.

    Tests whether this parallel iterable contains the given sequence at a given index.

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

    S

    the element type of that parallel sequence

    that

    the parallel sequence this sequence is being searched for

    offset

    the starting offset for the search

    returns

    true if there is a sequence that starting at offset in this sequence, false otherwise

    Definition Classes
    ParSeqLike → GenSeqLike
  122. def startsWith[B](that: GenSeq[B]): Boolean
    Definition Classes
    GenSeqLike
  123. def stringPrefix: String
    Definition Classes
    ParSeq → ParIterable → GenTraversableLike
  124. def sum[U >: Int](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike → GenTraversableOnce
  125. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  126. def tail: ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  127. def take(n: Int): ParSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableLike
  128. def takeWhile(pred: (Int) ⇒ Boolean): ParSeq[Int]

    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 iterable of elements that satisfy the predicate pred

    Definition Classes
    ParIterableLike → GenTraversableLike
  129. implicit def task2ops[R, Tp](tsk: SSCTask[R, Tp]): TaskOps[R, Tp]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  130. 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

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

  132. def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Int, Col[Int]]): Col[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  133. def toArray[U >: Int](implicit arg0: ClassTag[U]): Array[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  134. def toBuffer[U >: Int]: Buffer[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  135. def toIndexedSeq: immutable.IndexedSeq[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  136. def toIterable: ParIterable[Int]
    Definition Classes
    ParIterable → ParIterableLike → GenTraversableOnce
  137. def toIterator: scala.Iterator[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  138. def toList: List[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  139. def toMap[K, V](implicit ev: <:<[Int, (K, V)]): ParMap[K, V]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  140. def toParCollection[U >: Int, That](cbf: () ⇒ Combiner[U, That]): That
    Attributes
    protected
    Definition Classes
    ParIterableLike
  141. def toParMap[K, V, That](cbf: () ⇒ Combiner[(K, V), That])(implicit ev: <:<[Int, (K, V)]): That
    Attributes
    protected
    Definition Classes
    ParIterableLike
  142. def toSeq: ParSeq[Int]
    Definition Classes
    ParSeq → ParIterable → ParSeqLike → ParIterableLike → GenSeqLike → GenTraversableOnce
  143. def toSet[U >: Int]: ParSet[U]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  144. def toStream: Stream[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  145. def toString(): String
    Definition Classes
    ParRange → ParSeq → ParSeqLike → ParIterableLike → AnyRef → Any
  146. def toTraversable: GenTraversable[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  147. def toVector: Vector[Int]
    Definition Classes
    ParIterableLike → GenTraversableOnce
  148. def transpose[B](implicit asTraversable: (Int) ⇒ GenTraversableOnce[B]): ParSeq[ParSeq[B]]
    Definition Classes
    GenericTraversableTemplate
    Annotations
    @migration
    Migration

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

  149. def union[B >: Int, That](that: GenSeq[B])(implicit bf: CanBuildFrom[ParSeq[Int], B, That]): That
    Definition Classes
    GenSeqLike
  150. def unzip[A1, A2](implicit asPair: (Int) ⇒ (A1, A2)): (ParSeq[A1], ParSeq[A2])
    Definition Classes
    GenericTraversableTemplate
  151. def unzip3[A1, A2, A3](implicit asTriple: (Int) ⇒ (A1, A2, A3)): (ParSeq[A1], ParSeq[A2], ParSeq[A3])
    Definition Classes
    GenericTraversableTemplate
  152. def updated[U >: Int, That](index: Int, elem: U)(implicit bf: CanBuildFrom[ParSeq[Int], U, That]): That
    Definition Classes
    ParSeqLike → GenSeqLike
  153. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  154. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  155. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  156. def withFilter(pred: (Int) ⇒ Boolean): ParSeq[Int]
    Definition Classes
    ParIterableLike
  157. def wrap[R](body: ⇒ R): NonDivisible[R]
    Attributes
    protected
    Definition Classes
    ParIterableLike
  158. def zip[U >: Int, S, That](that: GenIterable[S])(implicit bf: CanBuildFrom[ParSeq[Int], (U, S), That]): That
    Definition Classes
    ParSeqLike → ParIterableLike → GenIterableLike
  159. def zipAll[S, U >: Int, That](that: GenIterable[S], thisElem: U, thatElem: S)(implicit bf: CanBuildFrom[ParSeq[Int], (U, S), That]): That
    Definition Classes
    ParIterableLike → GenIterableLike
  160. def zipWithIndex[U >: Int, That](implicit bf: CanBuildFrom[ParSeq[Int], (U, Int), That]): That
    Definition Classes
    ParIterableLike → GenIterableLike

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from ParSeq[Int]

Inherited from ParIterable[Int]

Inherited from Immutable

Inherited from parallel.ParSeq[Int]

Inherited from ParSeqLike[Int, ParSeq[Int], immutable.Seq[Int]]

Inherited from parallel.ParIterable[Int]

Inherited from ParIterableLike[Int, ParSeq[Int], immutable.Seq[Int]]

Inherited from Parallel

Inherited from CustomParallelizable[Int, ParSeq[Int]]

Inherited from Parallelizable[Int, ParSeq[Int]]

Inherited from GenericParTemplate[Int, ParSeq]

Inherited from HasNewCombiner[Int, scala.collection.parallel.immutable.ParSeq[Int] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenSeq[Int]

Inherited from GenIterable[Int]

Inherited from GenTraversable[Int]

Inherited from GenericTraversableTemplate[Int, ParSeq]

Inherited from HasNewBuilder[Int, scala.collection.parallel.immutable.ParSeq[Int] @scala.annotation.unchecked.uncheckedVariance]

Inherited from GenSeqLike[Int, ParSeq[Int]]

Inherited from Equals

Inherited from GenIterableLike[Int, ParSeq[Int]]

Inherited from GenTraversableLike[Int, ParSeq[Int]]

Inherited from GenTraversableOnce[Int]

Inherited from AnyRef

Inherited from Any

Ungrouped