trait ParSetLike[T, +CC[X] <: ParIterable[X], +Repr <: ParSet[T], +Sequential <: Set[T] with SetOps[T, Set, Sequential]] extends ParIterableLike[T, CC, Repr, Sequential] with (T) => Boolean with Equals

A template trait for parallel sets. This trait is mixed in with concrete parallel sets to override the representation type.

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.

T

the element type of the set

Self Type
ParSetLike[T, CC, Repr, Sequential]
Linear Supertypes
Equals, (T) => Boolean, ParIterableLike[T, CC, Repr, Sequential], HasNewCombiner[T, Repr], Parallel, CustomParallelizable[T, Repr], Parallelizable[T, Repr], IterableOnce[T], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ParSetLike
  2. Equals
  3. Function1
  4. ParIterableLike
  5. HasNewCombiner
  6. Parallel
  7. CustomParallelizable
  8. Parallelizable
  9. IterableOnce
  10. AnyRef
  11. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

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 +(elem: T): Repr
  2. abstract def -(elem: T): Repr
  3. abstract def companion: GenericParCompanion[CC]
    Definition Classes
    ParIterableLike
  4. abstract def contains(elem: T): Boolean
  5. abstract def empty: Repr
  6. abstract def seq: Sequential
    Definition Classes
    ParIterableLikeParallelizable
  7. abstract def size: Int
    Definition Classes
    ParIterableLike
  8. abstract def stringPrefix: String
    Definition Classes
    ParIterableLike

Concrete Value Members

  1. def &(that: Set[T]): Repr
  2. def &(that: ParSet[T]): Repr

    Computes the intersection between this set and another set.

    Computes the intersection between this set and another set.

    Note: Same as intersect.

    that

    the set to intersect with.

    returns

    a new set consisting of all elements that are both in this set and in the given set that.

  3. def &~(that: Set[T]): Repr
  4. def &~(that: ParSet[T]): Repr

    The difference of this set and another set.

    The difference of this set and another set.

    Note: Same as diff.

    that

    the set of elements to exclude.

    returns

    a set containing those elements of this set that are not also contained in the given set that.

  5. def ++[U >: T](that: scala.IterableOnce[U]): CC[U]
    Definition Classes
    ParIterableLike
  6. def /:[S](z: S)(op: (S, T) => S): S
    Definition Classes
    ParIterableLike
  7. def :\[S](z: S)(op: (T, S) => S): S
    Definition Classes
    ParIterableLike
  8. def aggregate[S](z: => S)(seqop: (S, T) => 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
  9. def andThen[A](g: (Boolean) => A): (T) => A
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  10. final def apply(elem: T): Boolean
    Definition Classes
    ParSetLike → Function1
  11. def canEqual(other: Any): Boolean
    Definition Classes
    ParSetLike → Equals
  12. def collect[S](pf: PartialFunction[T, S]): CC[S]
    Definition Classes
    ParIterableLike
  13. def compose[A](g: (A) => T): (A) => Boolean
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  14. def copyToArray[U >: T](xs: Array[U], start: Int, len: Int): Unit
    Definition Classes
    ParIterableLike
  15. def copyToArray[U >: T](xs: Array[U], start: Int): Unit
    Definition Classes
    ParIterableLike
  16. def copyToArray[U >: T](xs: Array[U]): Unit
    Definition Classes
    ParIterableLike
  17. def count(p: (T) => Boolean): Int
    Definition Classes
    ParIterableLike
  18. def debugBuffer: ArrayBuffer[String]
    Definition Classes
    ParIterableLike
  19. def diff(that: ParSet[T]): Repr
  20. def diff(that: Set[T]): Repr
  21. def drop(n: Int): Repr
    Definition Classes
    ParIterableLike
  22. def dropWhile(pred: (T) => Boolean): Repr

    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
  23. def equals(that: Any): Boolean

    Compares this set with another object for equality.

    Compares this set with another object for equality.

    Note: This operation contains an unchecked cast: if that is a set, it will assume with an unchecked cast that it has the same element type as this set. Any subsequent ClassCastException is treated as a false result.

    that

    the other object

    returns

    true if that is a set which contains the same elements as this set.

    Definition Classes
    ParSetLike → Equals → AnyRef → Any
  24. def exists(p: (T) => 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
  25. def filter(pred: (T) => Boolean): Repr
    Definition Classes
    ParIterableLike
  26. def filterNot(pred: (T) => Boolean): Repr
    Definition Classes
    ParIterableLike
  27. def find(p: (T) => Boolean): Option[T]

    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[S](f: (T) => scala.IterableOnce[S]): CC[S]
    Definition Classes
    ParIterableLike
  29. def fold[U >: T](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
  30. def foldLeft[S](z: S)(op: (S, T) => S): S
    Definition Classes
    ParIterableLike
  31. def foldRight[S](z: S)(op: (T, S) => S): S
    Definition Classes
    ParIterableLike
  32. def forall(p: (T) => 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
  33. def foreach[U](f: (T) => 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
  34. def groupBy[K](f: (T) => K): immutable.ParMap[K, Repr]
    Definition Classes
    ParIterableLike
  35. def hasDefiniteSize: Boolean
    Definition Classes
    ParIterableLike
  36. def hashCode(): Int
    Definition Classes
    ParSetLike → AnyRef → Any
  37. def head: T
    Definition Classes
    ParIterableLike
  38. def headOption: Option[T]
    Definition Classes
    ParIterableLike
  39. def init: Repr
    Definition Classes
    ParIterableLike
  40. def intersect(that: Set[T]): Repr
  41. def intersect(that: ParSet[T]): Repr

    Computes the intersection between this set and another set.

    Computes the intersection between this set and another set.

    that

    the set to intersect with.

    returns

    a new set consisting of all elements that are both in this set and in the given set that.

  42. def isEmpty: Boolean
    Definition Classes
    ParIterableLike
  43. 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
  44. final def isTraversableAgain: Boolean
    Definition Classes
    ParIterableLike
  45. def iterator: Splitter[T]

    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
  46. def knownSize: Int
    Definition Classes
    IterableOnce
  47. def last: T
    Definition Classes
    ParIterableLike
  48. def lastOption: Option[T]
    Definition Classes
    ParIterableLike
  49. def map[S](f: (T) => S): CC[S]
    Definition Classes
    ParIterableLike
  50. def max[U >: T](implicit ord: Ordering[U]): T
    Definition Classes
    ParIterableLike
  51. def maxBy[S](f: (T) => S)(implicit cmp: Ordering[S]): T
    Definition Classes
    ParIterableLike
  52. def min[U >: T](implicit ord: Ordering[U]): T
    Definition Classes
    ParIterableLike
  53. def minBy[S](f: (T) => S)(implicit cmp: Ordering[S]): T
    Definition Classes
    ParIterableLike
  54. def mkString: String
    Definition Classes
    ParIterableLike
  55. def mkString(sep: String): String
    Definition Classes
    ParIterableLike
  56. def mkString(start: String, sep: String, end: String): String
    Definition Classes
    ParIterableLike
  57. def nonEmpty: Boolean
    Definition Classes
    ParIterableLike
  58. def par: Repr

    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
  59. def partition(pred: (T) => Boolean): (Repr, Repr)
    Definition Classes
    ParIterableLike
  60. def product[U >: T](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike
  61. def reduce[U >: T](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 iterable is empty.

  62. def reduceLeft[U >: T](op: (U, T) => U): U
    Definition Classes
    ParIterableLike
  63. def reduceLeftOption[U >: T](op: (U, T) => U): Option[U]
    Definition Classes
    ParIterableLike
  64. def reduceOption[U >: T](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
  65. def reduceRight[U >: T](op: (T, U) => U): U
    Definition Classes
    ParIterableLike
  66. def reduceRightOption[U >: T](op: (T, U) => U): Option[U]
    Definition Classes
    ParIterableLike
  67. def repr: Repr
    Definition Classes
    ParIterableLike
  68. def sameElements[U >: T](that: scala.IterableOnce[U]): Boolean
    Definition Classes
    ParIterableLike
  69. def scan[U >: T](z: U)(op: (U, U) => U): CC[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 iterable containing the prefix scan of the elements in this parallel iterable

    Definition Classes
    ParIterableLike
  70. def scanLeft[S](z: S)(op: (S, T) => S): scala.Iterable[S]
    Definition Classes
    ParIterableLike
  71. def scanRight[S](z: S)(op: (T, S) => S): scala.Iterable[S]
    Definition Classes
    ParIterableLike
  72. def slice(unc_from: Int, unc_until: Int): Repr
    Definition Classes
    ParIterableLike
  73. def span(pred: (T) => Boolean): (Repr, Repr)

    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
  74. def splitAt(n: Int): (Repr, Repr)
    Definition Classes
    ParIterableLike
  75. def stepper[S <: Stepper[_]](implicit shape: StepperShape[T, S]): S
    Definition Classes
    IterableOnce
  76. def subsetOf(that: ParSet[T]): Boolean

    Tests whether this set is a subset of another set.

    Tests whether this set is a subset of another set.

    that

    the set to test.

    returns

    true if this set is a subset of that, i.e. if every element of this set is also an element of that.

  77. def sum[U >: T](implicit num: Numeric[U]): U
    Definition Classes
    ParIterableLike
  78. def tail: Repr
    Definition Classes
    ParIterableLike
  79. def take(n: Int): Repr
    Definition Classes
    ParIterableLike
  80. def takeWhile(pred: (T) => Boolean): Repr

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

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

  83. def to[C](factory: Factory[T, C]): C
    Definition Classes
    ParIterableLike
  84. def toArray[U >: T](implicit arg0: ClassTag[U]): Array[U]
    Definition Classes
    ParIterableLike
  85. def toBuffer[U >: T]: Buffer[U]
    Definition Classes
    ParIterableLike
  86. def toIndexedSeq: immutable.IndexedSeq[T]
    Definition Classes
    ParIterableLike
  87. def toIterable: ParIterable[T]
    Definition Classes
    ParIterableLike
  88. def toIterator: scala.Iterator[T]
    Definition Classes
    ParIterableLike
  89. def toList: List[T]
    Definition Classes
    ParIterableLike
  90. def toMap[K, V](implicit ev: <:<[T, (K, V)]): immutable.ParMap[K, V]
    Definition Classes
    ParIterableLike
  91. def toSeq: ParSeq[T]
    Definition Classes
    ParIterableLike
  92. def toSet[U >: T]: immutable.ParSet[U]
    Definition Classes
    ParIterableLike
  93. def toString(): String
    Definition Classes
    Function1 → AnyRef → Any
  94. def toVector: Vector[T]
    Definition Classes
    ParIterableLike
  95. def union(that: ParSet[T]): Repr
  96. def union(that: Set[T]): Repr
  97. def withFilter(pred: (T) => Boolean): Repr
    Definition Classes
    ParIterableLike
  98. def zip[U >: T, S](that: scala.Iterable[S]): CC[(U, S)]
    Definition Classes
    ParIterableLike
  99. def zip[U >: T, S](that: ParIterable[S]): CC[(U, S)]
    Definition Classes
    ParIterableLike
  100. def zipAll[S, U >: T](that: ParIterable[S], thisElem: U, thatElem: S): CC[(U, S)]
    Definition Classes
    ParIterableLike
  101. def zipWithIndex[U >: T]: CC[(U, Int)]

    Zips this parallel iterable with its indices.

    Zips this parallel iterable 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 ParIterable containing pairs consisting of all elements of this parallel iterable paired with their index. Indices start at 0.

    Definition Classes
    ParIterableLike
  102. def |(that: Set[T]): Repr
  103. def |(that: ParSet[T]): Repr

    Computes the union between this set and another set.

    Computes the union between this set and another set.

    Note: Same as union.

    that

    the set to form the union with.

    returns

    a new set consisting of all elements that are in this set or in the given set that.

Deprecated Value Members

  1. def toStream: Stream[T]
    Definition Classes
    ParIterableLike
    Annotations
    @deprecated
    Deprecated

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

  2. def toTraversable: ParIterable[T]
    Definition Classes
    ParIterableLike
    Annotations
    @deprecated
    Deprecated

    (Since version 0.1.3) Use toIterable instead